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(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN.
     19 // UNSUPPORTED: asan, msan
     20 
     21 // TODO GLIBC uses a different string for positive and negative NAN numbers.
     22 // XFAIL: linux-gnu
     23 
     24 #include <locale>
     25 #include <ios>
     26 #include <cassert>
     27 #include <streambuf>
     28 #include <cmath>
     29 #include "test_iterators.h"
     30 
     31 typedef std::num_put<char, output_iterator<char*> > F;
     32 
     33 class my_facet
     34     : public F
     35 {
     36 public:
     37     explicit my_facet(std::size_t refs = 0)
     38         : F(refs) {}
     39 };
     40 
     41 class my_numpunct
     42     : public std::numpunct<char>
     43 {
     44 public:
     45     my_numpunct() : std::numpunct<char>() {}
     46 
     47 protected:
     48     virtual char_type do_decimal_point() const {return ';';}
     49     virtual char_type do_thousands_sep() const {return '_';}
     50     virtual std::string do_grouping() const {return std::string("\1\2\3");}
     51 };
     52 
     53 void test1()
     54 {
     55     char str[200];
     56     output_iterator<char*> iter;
     57     std::locale lc = std::locale::classic();
     58     std::locale lg(lc, new my_numpunct);
     59     const my_facet f(1);
     60     {
     61         long double v = +0.;
     62         std::ios ios(0);
     63         // %g
     64         {
     65             ios.precision(0);
     66             {
     67                 nouppercase(ios);
     68                 {
     69                     noshowpos(ios);
     70                     {
     71                         noshowpoint(ios);
     72                         {
     73                             ios.imbue(lc);
     74                             {
     75                                 ios.width(0);
     76                                 {
     77                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
     78                                     std::string ex(str, iter.base());
     79                                     assert(ex == "0");
     80                                     assert(ios.width() == 0);
     81                                 }
     82                                 ios.width(25);
     83                                 left(ios);
     84                                 {
     85                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
     86                                     std::string ex(str, iter.base());
     87                                     assert(ex == "0************************");
     88                                     assert(ios.width() == 0);
     89                                 }
     90                                 ios.width(25);
     91                                 right(ios);
     92                                 {
     93                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
     94                                     std::string ex(str, iter.base());
     95                                     assert(ex == "************************0");
     96                                     assert(ios.width() == 0);
     97                                 }
     98                                 ios.width(25);
     99                                 internal(ios);
    100                                 {
    101                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    102                                     std::string ex(str, iter.base());
    103                                     assert(ex == "************************0");
    104                                     assert(ios.width() == 0);
    105                                 }
    106                             }
    107                             ios.imbue(lg);
    108                             {
    109                                 ios.width(0);
    110                                 {
    111                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    112                                     std::string ex(str, iter.base());
    113                                     assert(ex == "0");
    114                                     assert(ios.width() == 0);
    115                                 }
    116                                 ios.width(25);
    117                                 left(ios);
    118                                 {
    119                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    120                                     std::string ex(str, iter.base());
    121                                     assert(ex == "0************************");
    122                                     assert(ios.width() == 0);
    123                                 }
    124                                 ios.width(25);
    125                                 right(ios);
    126                                 {
    127                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    128                                     std::string ex(str, iter.base());
    129                                     assert(ex == "************************0");
    130                                     assert(ios.width() == 0);
    131                                 }
    132                                 ios.width(25);
    133                                 internal(ios);
    134                                 {
    135                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    136                                     std::string ex(str, iter.base());
    137                                     assert(ex == "************************0");
    138                                     assert(ios.width() == 0);
    139                                 }
    140                             }
    141                         }
    142                         showpoint(ios);
    143                         {
    144                             ios.imbue(lc);
    145                             {
    146                                 ios.width(0);
    147                                 {
    148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    149                                     std::string ex(str, iter.base());
    150                                     assert(ex == "0.");
    151                                     assert(ios.width() == 0);
    152                                 }
    153                                 ios.width(25);
    154                                 left(ios);
    155                                 {
    156                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    157                                     std::string ex(str, iter.base());
    158                                     assert(ex == "0.***********************");
    159                                     assert(ios.width() == 0);
    160                                 }
    161                                 ios.width(25);
    162                                 right(ios);
    163                                 {
    164                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    165                                     std::string ex(str, iter.base());
    166                                     assert(ex == "***********************0.");
    167                                     assert(ios.width() == 0);
    168                                 }
    169                                 ios.width(25);
    170                                 internal(ios);
    171                                 {
    172                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    173                                     std::string ex(str, iter.base());
    174                                     assert(ex == "***********************0.");
    175                                     assert(ios.width() == 0);
    176                                 }
    177                             }
    178                             ios.imbue(lg);
    179                             {
    180                                 ios.width(0);
    181                                 {
    182                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    183                                     std::string ex(str, iter.base());
    184                                     assert(ex == "0;");
    185                                     assert(ios.width() == 0);
    186                                 }
    187                                 ios.width(25);
    188                                 left(ios);
    189                                 {
    190                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    191                                     std::string ex(str, iter.base());
    192                                     assert(ex == "0;***********************");
    193                                     assert(ios.width() == 0);
    194                                 }
    195                                 ios.width(25);
    196                                 right(ios);
    197                                 {
    198                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    199                                     std::string ex(str, iter.base());
    200                                     assert(ex == "***********************0;");
    201                                     assert(ios.width() == 0);
    202                                 }
    203                                 ios.width(25);
    204                                 internal(ios);
    205                                 {
    206                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    207                                     std::string ex(str, iter.base());
    208                                     assert(ex == "***********************0;");
    209                                     assert(ios.width() == 0);
    210                                 }
    211                             }
    212                         }
    213                     }
    214                     showpos(ios);
    215                     {
    216                         noshowpoint(ios);
    217                         {
    218                             ios.imbue(lc);
    219                             {
    220                                 ios.width(0);
    221                                 {
    222                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    223                                     std::string ex(str, iter.base());
    224                                     assert(ex == "+0");
    225                                     assert(ios.width() == 0);
    226                                 }
    227                                 ios.width(25);
    228                                 left(ios);
    229                                 {
    230                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    231                                     std::string ex(str, iter.base());
    232                                     assert(ex == "+0***********************");
    233                                     assert(ios.width() == 0);
    234                                 }
    235                                 ios.width(25);
    236                                 right(ios);
    237                                 {
    238                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    239                                     std::string ex(str, iter.base());
    240                                     assert(ex == "***********************+0");
    241                                     assert(ios.width() == 0);
    242                                 }
    243                                 ios.width(25);
    244                                 internal(ios);
    245                                 {
    246                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    247                                     std::string ex(str, iter.base());
    248                                     assert(ex == "+***********************0");
    249                                     assert(ios.width() == 0);
    250                                 }
    251                             }
    252                             ios.imbue(lg);
    253                             {
    254                                 ios.width(0);
    255                                 {
    256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    257                                     std::string ex(str, iter.base());
    258                                     assert(ex == "+0");
    259                                     assert(ios.width() == 0);
    260                                 }
    261                                 ios.width(25);
    262                                 left(ios);
    263                                 {
    264                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    265                                     std::string ex(str, iter.base());
    266                                     assert(ex == "+0***********************");
    267                                     assert(ios.width() == 0);
    268                                 }
    269                                 ios.width(25);
    270                                 right(ios);
    271                                 {
    272                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    273                                     std::string ex(str, iter.base());
    274                                     assert(ex == "***********************+0");
    275                                     assert(ios.width() == 0);
    276                                 }
    277                                 ios.width(25);
    278                                 internal(ios);
    279                                 {
    280                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    281                                     std::string ex(str, iter.base());
    282                                     assert(ex == "+***********************0");
    283                                     assert(ios.width() == 0);
    284                                 }
    285                             }
    286                         }
    287                         showpoint(ios);
    288                         {
    289                             ios.imbue(lc);
    290                             {
    291                                 ios.width(0);
    292                                 {
    293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    294                                     std::string ex(str, iter.base());
    295                                     assert(ex == "+0.");
    296                                     assert(ios.width() == 0);
    297                                 }
    298                                 ios.width(25);
    299                                 left(ios);
    300                                 {
    301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    302                                     std::string ex(str, iter.base());
    303                                     assert(ex == "+0.**********************");
    304                                     assert(ios.width() == 0);
    305                                 }
    306                                 ios.width(25);
    307                                 right(ios);
    308                                 {
    309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    310                                     std::string ex(str, iter.base());
    311                                     assert(ex == "**********************+0.");
    312                                     assert(ios.width() == 0);
    313                                 }
    314                                 ios.width(25);
    315                                 internal(ios);
    316                                 {
    317                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    318                                     std::string ex(str, iter.base());
    319                                     assert(ex == "+**********************0.");
    320                                     assert(ios.width() == 0);
    321                                 }
    322                             }
    323                             ios.imbue(lg);
    324                             {
    325                                 ios.width(0);
    326                                 {
    327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    328                                     std::string ex(str, iter.base());
    329                                     assert(ex == "+0;");
    330                                     assert(ios.width() == 0);
    331                                 }
    332                                 ios.width(25);
    333                                 left(ios);
    334                                 {
    335                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    336                                     std::string ex(str, iter.base());
    337                                     assert(ex == "+0;**********************");
    338                                     assert(ios.width() == 0);
    339                                 }
    340                                 ios.width(25);
    341                                 right(ios);
    342                                 {
    343                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    344                                     std::string ex(str, iter.base());
    345                                     assert(ex == "**********************+0;");
    346                                     assert(ios.width() == 0);
    347                                 }
    348                                 ios.width(25);
    349                                 internal(ios);
    350                                 {
    351                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    352                                     std::string ex(str, iter.base());
    353                                     assert(ex == "+**********************0;");
    354                                     assert(ios.width() == 0);
    355                                 }
    356                             }
    357                         }
    358                     }
    359                 }
    360                 uppercase(ios);
    361                 {
    362                     noshowpos(ios);
    363                     {
    364                         noshowpoint(ios);
    365                         {
    366                             ios.imbue(lc);
    367                             {
    368                                 ios.width(0);
    369                                 {
    370                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    371                                     std::string ex(str, iter.base());
    372                                     assert(ex == "0");
    373                                     assert(ios.width() == 0);
    374                                 }
    375                                 ios.width(25);
    376                                 left(ios);
    377                                 {
    378                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    379                                     std::string ex(str, iter.base());
    380                                     assert(ex == "0************************");
    381                                     assert(ios.width() == 0);
    382                                 }
    383                                 ios.width(25);
    384                                 right(ios);
    385                                 {
    386                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    387                                     std::string ex(str, iter.base());
    388                                     assert(ex == "************************0");
    389                                     assert(ios.width() == 0);
    390                                 }
    391                                 ios.width(25);
    392                                 internal(ios);
    393                                 {
    394                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    395                                     std::string ex(str, iter.base());
    396                                     assert(ex == "************************0");
    397                                     assert(ios.width() == 0);
    398                                 }
    399                             }
    400                             ios.imbue(lg);
    401                             {
    402                                 ios.width(0);
    403                                 {
    404                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    405                                     std::string ex(str, iter.base());
    406                                     assert(ex == "0");
    407                                     assert(ios.width() == 0);
    408                                 }
    409                                 ios.width(25);
    410                                 left(ios);
    411                                 {
    412                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    413                                     std::string ex(str, iter.base());
    414                                     assert(ex == "0************************");
    415                                     assert(ios.width() == 0);
    416                                 }
    417                                 ios.width(25);
    418                                 right(ios);
    419                                 {
    420                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    421                                     std::string ex(str, iter.base());
    422                                     assert(ex == "************************0");
    423                                     assert(ios.width() == 0);
    424                                 }
    425                                 ios.width(25);
    426                                 internal(ios);
    427                                 {
    428                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    429                                     std::string ex(str, iter.base());
    430                                     assert(ex == "************************0");
    431                                     assert(ios.width() == 0);
    432                                 }
    433                             }
    434                         }
    435                         showpoint(ios);
    436                         {
    437                             ios.imbue(lc);
    438                             {
    439                                 ios.width(0);
    440                                 {
    441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    442                                     std::string ex(str, iter.base());
    443                                     assert(ex == "0.");
    444                                     assert(ios.width() == 0);
    445                                 }
    446                                 ios.width(25);
    447                                 left(ios);
    448                                 {
    449                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    450                                     std::string ex(str, iter.base());
    451                                     assert(ex == "0.***********************");
    452                                     assert(ios.width() == 0);
    453                                 }
    454                                 ios.width(25);
    455                                 right(ios);
    456                                 {
    457                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    458                                     std::string ex(str, iter.base());
    459                                     assert(ex == "***********************0.");
    460                                     assert(ios.width() == 0);
    461                                 }
    462                                 ios.width(25);
    463                                 internal(ios);
    464                                 {
    465                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    466                                     std::string ex(str, iter.base());
    467                                     assert(ex == "***********************0.");
    468                                     assert(ios.width() == 0);
    469                                 }
    470                             }
    471                             ios.imbue(lg);
    472                             {
    473                                 ios.width(0);
    474                                 {
    475                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    476                                     std::string ex(str, iter.base());
    477                                     assert(ex == "0;");
    478                                     assert(ios.width() == 0);
    479                                 }
    480                                 ios.width(25);
    481                                 left(ios);
    482                                 {
    483                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    484                                     std::string ex(str, iter.base());
    485                                     assert(ex == "0;***********************");
    486                                     assert(ios.width() == 0);
    487                                 }
    488                                 ios.width(25);
    489                                 right(ios);
    490                                 {
    491                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    492                                     std::string ex(str, iter.base());
    493                                     assert(ex == "***********************0;");
    494                                     assert(ios.width() == 0);
    495                                 }
    496                                 ios.width(25);
    497                                 internal(ios);
    498                                 {
    499                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    500                                     std::string ex(str, iter.base());
    501                                     assert(ex == "***********************0;");
    502                                     assert(ios.width() == 0);
    503                                 }
    504                             }
    505                         }
    506                     }
    507                     showpos(ios);
    508                     {
    509                         noshowpoint(ios);
    510                         {
    511                             ios.imbue(lc);
    512                             {
    513                                 ios.width(0);
    514                                 {
    515                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    516                                     std::string ex(str, iter.base());
    517                                     assert(ex == "+0");
    518                                     assert(ios.width() == 0);
    519                                 }
    520                                 ios.width(25);
    521                                 left(ios);
    522                                 {
    523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    524                                     std::string ex(str, iter.base());
    525                                     assert(ex == "+0***********************");
    526                                     assert(ios.width() == 0);
    527                                 }
    528                                 ios.width(25);
    529                                 right(ios);
    530                                 {
    531                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    532                                     std::string ex(str, iter.base());
    533                                     assert(ex == "***********************+0");
    534                                     assert(ios.width() == 0);
    535                                 }
    536                                 ios.width(25);
    537                                 internal(ios);
    538                                 {
    539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    540                                     std::string ex(str, iter.base());
    541                                     assert(ex == "+***********************0");
    542                                     assert(ios.width() == 0);
    543                                 }
    544                             }
    545                             ios.imbue(lg);
    546                             {
    547                                 ios.width(0);
    548                                 {
    549                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    550                                     std::string ex(str, iter.base());
    551                                     assert(ex == "+0");
    552                                     assert(ios.width() == 0);
    553                                 }
    554                                 ios.width(25);
    555                                 left(ios);
    556                                 {
    557                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    558                                     std::string ex(str, iter.base());
    559                                     assert(ex == "+0***********************");
    560                                     assert(ios.width() == 0);
    561                                 }
    562                                 ios.width(25);
    563                                 right(ios);
    564                                 {
    565                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    566                                     std::string ex(str, iter.base());
    567                                     assert(ex == "***********************+0");
    568                                     assert(ios.width() == 0);
    569                                 }
    570                                 ios.width(25);
    571                                 internal(ios);
    572                                 {
    573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    574                                     std::string ex(str, iter.base());
    575                                     assert(ex == "+***********************0");
    576                                     assert(ios.width() == 0);
    577                                 }
    578                             }
    579                         }
    580                         showpoint(ios);
    581                         {
    582                             ios.imbue(lc);
    583                             {
    584                                 ios.width(0);
    585                                 {
    586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    587                                     std::string ex(str, iter.base());
    588                                     assert(ex == "+0.");
    589                                     assert(ios.width() == 0);
    590                                 }
    591                                 ios.width(25);
    592                                 left(ios);
    593                                 {
    594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    595                                     std::string ex(str, iter.base());
    596                                     assert(ex == "+0.**********************");
    597                                     assert(ios.width() == 0);
    598                                 }
    599                                 ios.width(25);
    600                                 right(ios);
    601                                 {
    602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    603                                     std::string ex(str, iter.base());
    604                                     assert(ex == "**********************+0.");
    605                                     assert(ios.width() == 0);
    606                                 }
    607                                 ios.width(25);
    608                                 internal(ios);
    609                                 {
    610                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    611                                     std::string ex(str, iter.base());
    612                                     assert(ex == "+**********************0.");
    613                                     assert(ios.width() == 0);
    614                                 }
    615                             }
    616                             ios.imbue(lg);
    617                             {
    618                                 ios.width(0);
    619                                 {
    620                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    621                                     std::string ex(str, iter.base());
    622                                     assert(ex == "+0;");
    623                                     assert(ios.width() == 0);
    624                                 }
    625                                 ios.width(25);
    626                                 left(ios);
    627                                 {
    628                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    629                                     std::string ex(str, iter.base());
    630                                     assert(ex == "+0;**********************");
    631                                     assert(ios.width() == 0);
    632                                 }
    633                                 ios.width(25);
    634                                 right(ios);
    635                                 {
    636                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    637                                     std::string ex(str, iter.base());
    638                                     assert(ex == "**********************+0;");
    639                                     assert(ios.width() == 0);
    640                                 }
    641                                 ios.width(25);
    642                                 internal(ios);
    643                                 {
    644                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    645                                     std::string ex(str, iter.base());
    646                                     assert(ex == "+**********************0;");
    647                                     assert(ios.width() == 0);
    648                                 }
    649                             }
    650                         }
    651                     }
    652                 }
    653             }
    654             ios.precision(1);
    655             {
    656                 nouppercase(ios);
    657                 {
    658                     noshowpos(ios);
    659                     {
    660                         noshowpoint(ios);
    661                         {
    662                             ios.imbue(lc);
    663                             {
    664                                 ios.width(0);
    665                                 {
    666                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    667                                     std::string ex(str, iter.base());
    668                                     assert(ex == "0");
    669                                     assert(ios.width() == 0);
    670                                 }
    671                                 ios.width(25);
    672                                 left(ios);
    673                                 {
    674                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    675                                     std::string ex(str, iter.base());
    676                                     assert(ex == "0************************");
    677                                     assert(ios.width() == 0);
    678                                 }
    679                                 ios.width(25);
    680                                 right(ios);
    681                                 {
    682                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    683                                     std::string ex(str, iter.base());
    684                                     assert(ex == "************************0");
    685                                     assert(ios.width() == 0);
    686                                 }
    687                                 ios.width(25);
    688                                 internal(ios);
    689                                 {
    690                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    691                                     std::string ex(str, iter.base());
    692                                     assert(ex == "************************0");
    693                                     assert(ios.width() == 0);
    694                                 }
    695                             }
    696                             ios.imbue(lg);
    697                             {
    698                                 ios.width(0);
    699                                 {
    700                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    701                                     std::string ex(str, iter.base());
    702                                     assert(ex == "0");
    703                                     assert(ios.width() == 0);
    704                                 }
    705                                 ios.width(25);
    706                                 left(ios);
    707                                 {
    708                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    709                                     std::string ex(str, iter.base());
    710                                     assert(ex == "0************************");
    711                                     assert(ios.width() == 0);
    712                                 }
    713                                 ios.width(25);
    714                                 right(ios);
    715                                 {
    716                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    717                                     std::string ex(str, iter.base());
    718                                     assert(ex == "************************0");
    719                                     assert(ios.width() == 0);
    720                                 }
    721                                 ios.width(25);
    722                                 internal(ios);
    723                                 {
    724                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    725                                     std::string ex(str, iter.base());
    726                                     assert(ex == "************************0");
    727                                     assert(ios.width() == 0);
    728                                 }
    729                             }
    730                         }
    731                         showpoint(ios);
    732                         {
    733                             ios.imbue(lc);
    734                             {
    735                                 ios.width(0);
    736                                 {
    737                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    738                                     std::string ex(str, iter.base());
    739                                     assert(ex == "0.");
    740                                     assert(ios.width() == 0);
    741                                 }
    742                                 ios.width(25);
    743                                 left(ios);
    744                                 {
    745                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    746                                     std::string ex(str, iter.base());
    747                                     assert(ex == "0.***********************");
    748                                     assert(ios.width() == 0);
    749                                 }
    750                                 ios.width(25);
    751                                 right(ios);
    752                                 {
    753                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    754                                     std::string ex(str, iter.base());
    755                                     assert(ex == "***********************0.");
    756                                     assert(ios.width() == 0);
    757                                 }
    758                                 ios.width(25);
    759                                 internal(ios);
    760                                 {
    761                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    762                                     std::string ex(str, iter.base());
    763                                     assert(ex == "***********************0.");
    764                                     assert(ios.width() == 0);
    765                                 }
    766                             }
    767                             ios.imbue(lg);
    768                             {
    769                                 ios.width(0);
    770                                 {
    771                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    772                                     std::string ex(str, iter.base());
    773                                     assert(ex == "0;");
    774                                     assert(ios.width() == 0);
    775                                 }
    776                                 ios.width(25);
    777                                 left(ios);
    778                                 {
    779                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    780                                     std::string ex(str, iter.base());
    781                                     assert(ex == "0;***********************");
    782                                     assert(ios.width() == 0);
    783                                 }
    784                                 ios.width(25);
    785                                 right(ios);
    786                                 {
    787                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    788                                     std::string ex(str, iter.base());
    789                                     assert(ex == "***********************0;");
    790                                     assert(ios.width() == 0);
    791                                 }
    792                                 ios.width(25);
    793                                 internal(ios);
    794                                 {
    795                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    796                                     std::string ex(str, iter.base());
    797                                     assert(ex == "***********************0;");
    798                                     assert(ios.width() == 0);
    799                                 }
    800                             }
    801                         }
    802                     }
    803                     showpos(ios);
    804                     {
    805                         noshowpoint(ios);
    806                         {
    807                             ios.imbue(lc);
    808                             {
    809                                 ios.width(0);
    810                                 {
    811                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    812                                     std::string ex(str, iter.base());
    813                                     assert(ex == "+0");
    814                                     assert(ios.width() == 0);
    815                                 }
    816                                 ios.width(25);
    817                                 left(ios);
    818                                 {
    819                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    820                                     std::string ex(str, iter.base());
    821                                     assert(ex == "+0***********************");
    822                                     assert(ios.width() == 0);
    823                                 }
    824                                 ios.width(25);
    825                                 right(ios);
    826                                 {
    827                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    828                                     std::string ex(str, iter.base());
    829                                     assert(ex == "***********************+0");
    830                                     assert(ios.width() == 0);
    831                                 }
    832                                 ios.width(25);
    833                                 internal(ios);
    834                                 {
    835                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    836                                     std::string ex(str, iter.base());
    837                                     assert(ex == "+***********************0");
    838                                     assert(ios.width() == 0);
    839                                 }
    840                             }
    841                             ios.imbue(lg);
    842                             {
    843                                 ios.width(0);
    844                                 {
    845                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    846                                     std::string ex(str, iter.base());
    847                                     assert(ex == "+0");
    848                                     assert(ios.width() == 0);
    849                                 }
    850                                 ios.width(25);
    851                                 left(ios);
    852                                 {
    853                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    854                                     std::string ex(str, iter.base());
    855                                     assert(ex == "+0***********************");
    856                                     assert(ios.width() == 0);
    857                                 }
    858                                 ios.width(25);
    859                                 right(ios);
    860                                 {
    861                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    862                                     std::string ex(str, iter.base());
    863                                     assert(ex == "***********************+0");
    864                                     assert(ios.width() == 0);
    865                                 }
    866                                 ios.width(25);
    867                                 internal(ios);
    868                                 {
    869                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    870                                     std::string ex(str, iter.base());
    871                                     assert(ex == "+***********************0");
    872                                     assert(ios.width() == 0);
    873                                 }
    874                             }
    875                         }
    876                         showpoint(ios);
    877                         {
    878                             ios.imbue(lc);
    879                             {
    880                                 ios.width(0);
    881                                 {
    882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    883                                     std::string ex(str, iter.base());
    884                                     assert(ex == "+0.");
    885                                     assert(ios.width() == 0);
    886                                 }
    887                                 ios.width(25);
    888                                 left(ios);
    889                                 {
    890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    891                                     std::string ex(str, iter.base());
    892                                     assert(ex == "+0.**********************");
    893                                     assert(ios.width() == 0);
    894                                 }
    895                                 ios.width(25);
    896                                 right(ios);
    897                                 {
    898                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    899                                     std::string ex(str, iter.base());
    900                                     assert(ex == "**********************+0.");
    901                                     assert(ios.width() == 0);
    902                                 }
    903                                 ios.width(25);
    904                                 internal(ios);
    905                                 {
    906                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    907                                     std::string ex(str, iter.base());
    908                                     assert(ex == "+**********************0.");
    909                                     assert(ios.width() == 0);
    910                                 }
    911                             }
    912                             ios.imbue(lg);
    913                             {
    914                                 ios.width(0);
    915                                 {
    916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    917                                     std::string ex(str, iter.base());
    918                                     assert(ex == "+0;");
    919                                     assert(ios.width() == 0);
    920                                 }
    921                                 ios.width(25);
    922                                 left(ios);
    923                                 {
    924                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    925                                     std::string ex(str, iter.base());
    926                                     assert(ex == "+0;**********************");
    927                                     assert(ios.width() == 0);
    928                                 }
    929                                 ios.width(25);
    930                                 right(ios);
    931                                 {
    932                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    933                                     std::string ex(str, iter.base());
    934                                     assert(ex == "**********************+0;");
    935                                     assert(ios.width() == 0);
    936                                 }
    937                                 ios.width(25);
    938                                 internal(ios);
    939                                 {
    940                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    941                                     std::string ex(str, iter.base());
    942                                     assert(ex == "+**********************0;");
    943                                     assert(ios.width() == 0);
    944                                 }
    945                             }
    946                         }
    947                     }
    948                 }
    949                 uppercase(ios);
    950                 {
    951                     noshowpos(ios);
    952                     {
    953                         noshowpoint(ios);
    954                         {
    955                             ios.imbue(lc);
    956                             {
    957                                 ios.width(0);
    958                                 {
    959                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    960                                     std::string ex(str, iter.base());
    961                                     assert(ex == "0");
    962                                     assert(ios.width() == 0);
    963                                 }
    964                                 ios.width(25);
    965                                 left(ios);
    966                                 {
    967                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    968                                     std::string ex(str, iter.base());
    969                                     assert(ex == "0************************");
    970                                     assert(ios.width() == 0);
    971                                 }
    972                                 ios.width(25);
    973                                 right(ios);
    974                                 {
    975                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    976                                     std::string ex(str, iter.base());
    977                                     assert(ex == "************************0");
    978                                     assert(ios.width() == 0);
    979                                 }
    980                                 ios.width(25);
    981                                 internal(ios);
    982                                 {
    983                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    984                                     std::string ex(str, iter.base());
    985                                     assert(ex == "************************0");
    986                                     assert(ios.width() == 0);
    987                                 }
    988                             }
    989                             ios.imbue(lg);
    990                             {
    991                                 ios.width(0);
    992                                 {
    993                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
    994                                     std::string ex(str, iter.base());
    995                                     assert(ex == "0");
    996                                     assert(ios.width() == 0);
    997                                 }
    998                                 ios.width(25);
    999                                 left(ios);
   1000                                 {
   1001                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1002                                     std::string ex(str, iter.base());
   1003                                     assert(ex == "0************************");
   1004                                     assert(ios.width() == 0);
   1005                                 }
   1006                                 ios.width(25);
   1007                                 right(ios);
   1008                                 {
   1009                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1010                                     std::string ex(str, iter.base());
   1011                                     assert(ex == "************************0");
   1012                                     assert(ios.width() == 0);
   1013                                 }
   1014                                 ios.width(25);
   1015                                 internal(ios);
   1016                                 {
   1017                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1018                                     std::string ex(str, iter.base());
   1019                                     assert(ex == "************************0");
   1020                                     assert(ios.width() == 0);
   1021                                 }
   1022                             }
   1023                         }
   1024                         showpoint(ios);
   1025                         {
   1026                             ios.imbue(lc);
   1027                             {
   1028                                 ios.width(0);
   1029                                 {
   1030                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1031                                     std::string ex(str, iter.base());
   1032                                     assert(ex == "0.");
   1033                                     assert(ios.width() == 0);
   1034                                 }
   1035                                 ios.width(25);
   1036                                 left(ios);
   1037                                 {
   1038                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1039                                     std::string ex(str, iter.base());
   1040                                     assert(ex == "0.***********************");
   1041                                     assert(ios.width() == 0);
   1042                                 }
   1043                                 ios.width(25);
   1044                                 right(ios);
   1045                                 {
   1046                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1047                                     std::string ex(str, iter.base());
   1048                                     assert(ex == "***********************0.");
   1049                                     assert(ios.width() == 0);
   1050                                 }
   1051                                 ios.width(25);
   1052                                 internal(ios);
   1053                                 {
   1054                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1055                                     std::string ex(str, iter.base());
   1056                                     assert(ex == "***********************0.");
   1057                                     assert(ios.width() == 0);
   1058                                 }
   1059                             }
   1060                             ios.imbue(lg);
   1061                             {
   1062                                 ios.width(0);
   1063                                 {
   1064                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1065                                     std::string ex(str, iter.base());
   1066                                     assert(ex == "0;");
   1067                                     assert(ios.width() == 0);
   1068                                 }
   1069                                 ios.width(25);
   1070                                 left(ios);
   1071                                 {
   1072                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1073                                     std::string ex(str, iter.base());
   1074                                     assert(ex == "0;***********************");
   1075                                     assert(ios.width() == 0);
   1076                                 }
   1077                                 ios.width(25);
   1078                                 right(ios);
   1079                                 {
   1080                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1081                                     std::string ex(str, iter.base());
   1082                                     assert(ex == "***********************0;");
   1083                                     assert(ios.width() == 0);
   1084                                 }
   1085                                 ios.width(25);
   1086                                 internal(ios);
   1087                                 {
   1088                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1089                                     std::string ex(str, iter.base());
   1090                                     assert(ex == "***********************0;");
   1091                                     assert(ios.width() == 0);
   1092                                 }
   1093                             }
   1094                         }
   1095                     }
   1096                     showpos(ios);
   1097                     {
   1098                         noshowpoint(ios);
   1099                         {
   1100                             ios.imbue(lc);
   1101                             {
   1102                                 ios.width(0);
   1103                                 {
   1104                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1105                                     std::string ex(str, iter.base());
   1106                                     assert(ex == "+0");
   1107                                     assert(ios.width() == 0);
   1108                                 }
   1109                                 ios.width(25);
   1110                                 left(ios);
   1111                                 {
   1112                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1113                                     std::string ex(str, iter.base());
   1114                                     assert(ex == "+0***********************");
   1115                                     assert(ios.width() == 0);
   1116                                 }
   1117                                 ios.width(25);
   1118                                 right(ios);
   1119                                 {
   1120                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1121                                     std::string ex(str, iter.base());
   1122                                     assert(ex == "***********************+0");
   1123                                     assert(ios.width() == 0);
   1124                                 }
   1125                                 ios.width(25);
   1126                                 internal(ios);
   1127                                 {
   1128                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1129                                     std::string ex(str, iter.base());
   1130                                     assert(ex == "+***********************0");
   1131                                     assert(ios.width() == 0);
   1132                                 }
   1133                             }
   1134                             ios.imbue(lg);
   1135                             {
   1136                                 ios.width(0);
   1137                                 {
   1138                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1139                                     std::string ex(str, iter.base());
   1140                                     assert(ex == "+0");
   1141                                     assert(ios.width() == 0);
   1142                                 }
   1143                                 ios.width(25);
   1144                                 left(ios);
   1145                                 {
   1146                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1147                                     std::string ex(str, iter.base());
   1148                                     assert(ex == "+0***********************");
   1149                                     assert(ios.width() == 0);
   1150                                 }
   1151                                 ios.width(25);
   1152                                 right(ios);
   1153                                 {
   1154                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1155                                     std::string ex(str, iter.base());
   1156                                     assert(ex == "***********************+0");
   1157                                     assert(ios.width() == 0);
   1158                                 }
   1159                                 ios.width(25);
   1160                                 internal(ios);
   1161                                 {
   1162                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1163                                     std::string ex(str, iter.base());
   1164                                     assert(ex == "+***********************0");
   1165                                     assert(ios.width() == 0);
   1166                                 }
   1167                             }
   1168                         }
   1169                         showpoint(ios);
   1170                         {
   1171                             ios.imbue(lc);
   1172                             {
   1173                                 ios.width(0);
   1174                                 {
   1175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1176                                     std::string ex(str, iter.base());
   1177                                     assert(ex == "+0.");
   1178                                     assert(ios.width() == 0);
   1179                                 }
   1180                                 ios.width(25);
   1181                                 left(ios);
   1182                                 {
   1183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1184                                     std::string ex(str, iter.base());
   1185                                     assert(ex == "+0.**********************");
   1186                                     assert(ios.width() == 0);
   1187                                 }
   1188                                 ios.width(25);
   1189                                 right(ios);
   1190                                 {
   1191                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1192                                     std::string ex(str, iter.base());
   1193                                     assert(ex == "**********************+0.");
   1194                                     assert(ios.width() == 0);
   1195                                 }
   1196                                 ios.width(25);
   1197                                 internal(ios);
   1198                                 {
   1199                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1200                                     std::string ex(str, iter.base());
   1201                                     assert(ex == "+**********************0.");
   1202                                     assert(ios.width() == 0);
   1203                                 }
   1204                             }
   1205                             ios.imbue(lg);
   1206                             {
   1207                                 ios.width(0);
   1208                                 {
   1209                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1210                                     std::string ex(str, iter.base());
   1211                                     assert(ex == "+0;");
   1212                                     assert(ios.width() == 0);
   1213                                 }
   1214                                 ios.width(25);
   1215                                 left(ios);
   1216                                 {
   1217                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1218                                     std::string ex(str, iter.base());
   1219                                     assert(ex == "+0;**********************");
   1220                                     assert(ios.width() == 0);
   1221                                 }
   1222                                 ios.width(25);
   1223                                 right(ios);
   1224                                 {
   1225                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1226                                     std::string ex(str, iter.base());
   1227                                     assert(ex == "**********************+0;");
   1228                                     assert(ios.width() == 0);
   1229                                 }
   1230                                 ios.width(25);
   1231                                 internal(ios);
   1232                                 {
   1233                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1234                                     std::string ex(str, iter.base());
   1235                                     assert(ex == "+**********************0;");
   1236                                     assert(ios.width() == 0);
   1237                                 }
   1238                             }
   1239                         }
   1240                     }
   1241                 }
   1242             }
   1243             ios.precision(6);
   1244             {
   1245                 nouppercase(ios);
   1246                 {
   1247                     noshowpos(ios);
   1248                     {
   1249                         noshowpoint(ios);
   1250                         {
   1251                             ios.imbue(lc);
   1252                             {
   1253                                 ios.width(0);
   1254                                 {
   1255                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1256                                     std::string ex(str, iter.base());
   1257                                     assert(ex == "0");
   1258                                     assert(ios.width() == 0);
   1259                                 }
   1260                                 ios.width(25);
   1261                                 left(ios);
   1262                                 {
   1263                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1264                                     std::string ex(str, iter.base());
   1265                                     assert(ex == "0************************");
   1266                                     assert(ios.width() == 0);
   1267                                 }
   1268                                 ios.width(25);
   1269                                 right(ios);
   1270                                 {
   1271                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1272                                     std::string ex(str, iter.base());
   1273                                     assert(ex == "************************0");
   1274                                     assert(ios.width() == 0);
   1275                                 }
   1276                                 ios.width(25);
   1277                                 internal(ios);
   1278                                 {
   1279                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1280                                     std::string ex(str, iter.base());
   1281                                     assert(ex == "************************0");
   1282                                     assert(ios.width() == 0);
   1283                                 }
   1284                             }
   1285                             ios.imbue(lg);
   1286                             {
   1287                                 ios.width(0);
   1288                                 {
   1289                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1290                                     std::string ex(str, iter.base());
   1291                                     assert(ex == "0");
   1292                                     assert(ios.width() == 0);
   1293                                 }
   1294                                 ios.width(25);
   1295                                 left(ios);
   1296                                 {
   1297                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1298                                     std::string ex(str, iter.base());
   1299                                     assert(ex == "0************************");
   1300                                     assert(ios.width() == 0);
   1301                                 }
   1302                                 ios.width(25);
   1303                                 right(ios);
   1304                                 {
   1305                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1306                                     std::string ex(str, iter.base());
   1307                                     assert(ex == "************************0");
   1308                                     assert(ios.width() == 0);
   1309                                 }
   1310                                 ios.width(25);
   1311                                 internal(ios);
   1312                                 {
   1313                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1314                                     std::string ex(str, iter.base());
   1315                                     assert(ex == "************************0");
   1316                                     assert(ios.width() == 0);
   1317                                 }
   1318                             }
   1319                         }
   1320                         showpoint(ios);
   1321                         {
   1322                             ios.imbue(lc);
   1323                             {
   1324                                 ios.width(0);
   1325                                 {
   1326                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1327                                     std::string ex(str, iter.base());
   1328                                     assert(ex == "0.00000");
   1329                                     assert(ios.width() == 0);
   1330                                 }
   1331                                 ios.width(25);
   1332                                 left(ios);
   1333                                 {
   1334                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1335                                     std::string ex(str, iter.base());
   1336                                     assert(ex == "0.00000******************");
   1337                                     assert(ios.width() == 0);
   1338                                 }
   1339                                 ios.width(25);
   1340                                 right(ios);
   1341                                 {
   1342                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1343                                     std::string ex(str, iter.base());
   1344                                     assert(ex == "******************0.00000");
   1345                                     assert(ios.width() == 0);
   1346                                 }
   1347                                 ios.width(25);
   1348                                 internal(ios);
   1349                                 {
   1350                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1351                                     std::string ex(str, iter.base());
   1352                                     assert(ex == "******************0.00000");
   1353                                     assert(ios.width() == 0);
   1354                                 }
   1355                             }
   1356                             ios.imbue(lg);
   1357                             {
   1358                                 ios.width(0);
   1359                                 {
   1360                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1361                                     std::string ex(str, iter.base());
   1362                                     assert(ex == "0;00000");
   1363                                     assert(ios.width() == 0);
   1364                                 }
   1365                                 ios.width(25);
   1366                                 left(ios);
   1367                                 {
   1368                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1369                                     std::string ex(str, iter.base());
   1370                                     assert(ex == "0;00000******************");
   1371                                     assert(ios.width() == 0);
   1372                                 }
   1373                                 ios.width(25);
   1374                                 right(ios);
   1375                                 {
   1376                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1377                                     std::string ex(str, iter.base());
   1378                                     assert(ex == "******************0;00000");
   1379                                     assert(ios.width() == 0);
   1380                                 }
   1381                                 ios.width(25);
   1382                                 internal(ios);
   1383                                 {
   1384                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1385                                     std::string ex(str, iter.base());
   1386                                     assert(ex == "******************0;00000");
   1387                                     assert(ios.width() == 0);
   1388                                 }
   1389                             }
   1390                         }
   1391                     }
   1392                     showpos(ios);
   1393                     {
   1394                         noshowpoint(ios);
   1395                         {
   1396                             ios.imbue(lc);
   1397                             {
   1398                                 ios.width(0);
   1399                                 {
   1400                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1401                                     std::string ex(str, iter.base());
   1402                                     assert(ex == "+0");
   1403                                     assert(ios.width() == 0);
   1404                                 }
   1405                                 ios.width(25);
   1406                                 left(ios);
   1407                                 {
   1408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1409                                     std::string ex(str, iter.base());
   1410                                     assert(ex == "+0***********************");
   1411                                     assert(ios.width() == 0);
   1412                                 }
   1413                                 ios.width(25);
   1414                                 right(ios);
   1415                                 {
   1416                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1417                                     std::string ex(str, iter.base());
   1418                                     assert(ex == "***********************+0");
   1419                                     assert(ios.width() == 0);
   1420                                 }
   1421                                 ios.width(25);
   1422                                 internal(ios);
   1423                                 {
   1424                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1425                                     std::string ex(str, iter.base());
   1426                                     assert(ex == "+***********************0");
   1427                                     assert(ios.width() == 0);
   1428                                 }
   1429                             }
   1430                             ios.imbue(lg);
   1431                             {
   1432                                 ios.width(0);
   1433                                 {
   1434                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1435                                     std::string ex(str, iter.base());
   1436                                     assert(ex == "+0");
   1437                                     assert(ios.width() == 0);
   1438                                 }
   1439                                 ios.width(25);
   1440                                 left(ios);
   1441                                 {
   1442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1443                                     std::string ex(str, iter.base());
   1444                                     assert(ex == "+0***********************");
   1445                                     assert(ios.width() == 0);
   1446                                 }
   1447                                 ios.width(25);
   1448                                 right(ios);
   1449                                 {
   1450                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1451                                     std::string ex(str, iter.base());
   1452                                     assert(ex == "***********************+0");
   1453                                     assert(ios.width() == 0);
   1454                                 }
   1455                                 ios.width(25);
   1456                                 internal(ios);
   1457                                 {
   1458                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1459                                     std::string ex(str, iter.base());
   1460                                     assert(ex == "+***********************0");
   1461                                     assert(ios.width() == 0);
   1462                                 }
   1463                             }
   1464                         }
   1465                         showpoint(ios);
   1466                         {
   1467                             ios.imbue(lc);
   1468                             {
   1469                                 ios.width(0);
   1470                                 {
   1471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1472                                     std::string ex(str, iter.base());
   1473                                     assert(ex == "+0.00000");
   1474                                     assert(ios.width() == 0);
   1475                                 }
   1476                                 ios.width(25);
   1477                                 left(ios);
   1478                                 {
   1479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1480                                     std::string ex(str, iter.base());
   1481                                     assert(ex == "+0.00000*****************");
   1482                                     assert(ios.width() == 0);
   1483                                 }
   1484                                 ios.width(25);
   1485                                 right(ios);
   1486                                 {
   1487                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1488                                     std::string ex(str, iter.base());
   1489                                     assert(ex == "*****************+0.00000");
   1490                                     assert(ios.width() == 0);
   1491                                 }
   1492                                 ios.width(25);
   1493                                 internal(ios);
   1494                                 {
   1495                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1496                                     std::string ex(str, iter.base());
   1497                                     assert(ex == "+*****************0.00000");
   1498                                     assert(ios.width() == 0);
   1499                                 }
   1500                             }
   1501                             ios.imbue(lg);
   1502                             {
   1503                                 ios.width(0);
   1504                                 {
   1505                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1506                                     std::string ex(str, iter.base());
   1507                                     assert(ex == "+0;00000");
   1508                                     assert(ios.width() == 0);
   1509                                 }
   1510                                 ios.width(25);
   1511                                 left(ios);
   1512                                 {
   1513                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1514                                     std::string ex(str, iter.base());
   1515                                     assert(ex == "+0;00000*****************");
   1516                                     assert(ios.width() == 0);
   1517                                 }
   1518                                 ios.width(25);
   1519                                 right(ios);
   1520                                 {
   1521                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1522                                     std::string ex(str, iter.base());
   1523                                     assert(ex == "*****************+0;00000");
   1524                                     assert(ios.width() == 0);
   1525                                 }
   1526                                 ios.width(25);
   1527                                 internal(ios);
   1528                                 {
   1529                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1530                                     std::string ex(str, iter.base());
   1531                                     assert(ex == "+*****************0;00000");
   1532                                     assert(ios.width() == 0);
   1533                                 }
   1534                             }
   1535                         }
   1536                     }
   1537                 }
   1538                 uppercase(ios);
   1539                 {
   1540                     noshowpos(ios);
   1541                     {
   1542                         noshowpoint(ios);
   1543                         {
   1544                             ios.imbue(lc);
   1545                             {
   1546                                 ios.width(0);
   1547                                 {
   1548                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1549                                     std::string ex(str, iter.base());
   1550                                     assert(ex == "0");
   1551                                     assert(ios.width() == 0);
   1552                                 }
   1553                                 ios.width(25);
   1554                                 left(ios);
   1555                                 {
   1556                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1557                                     std::string ex(str, iter.base());
   1558                                     assert(ex == "0************************");
   1559                                     assert(ios.width() == 0);
   1560                                 }
   1561                                 ios.width(25);
   1562                                 right(ios);
   1563                                 {
   1564                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1565                                     std::string ex(str, iter.base());
   1566                                     assert(ex == "************************0");
   1567                                     assert(ios.width() == 0);
   1568                                 }
   1569                                 ios.width(25);
   1570                                 internal(ios);
   1571                                 {
   1572                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1573                                     std::string ex(str, iter.base());
   1574                                     assert(ex == "************************0");
   1575                                     assert(ios.width() == 0);
   1576                                 }
   1577                             }
   1578                             ios.imbue(lg);
   1579                             {
   1580                                 ios.width(0);
   1581                                 {
   1582                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1583                                     std::string ex(str, iter.base());
   1584                                     assert(ex == "0");
   1585                                     assert(ios.width() == 0);
   1586                                 }
   1587                                 ios.width(25);
   1588                                 left(ios);
   1589                                 {
   1590                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1591                                     std::string ex(str, iter.base());
   1592                                     assert(ex == "0************************");
   1593                                     assert(ios.width() == 0);
   1594                                 }
   1595                                 ios.width(25);
   1596                                 right(ios);
   1597                                 {
   1598                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1599                                     std::string ex(str, iter.base());
   1600                                     assert(ex == "************************0");
   1601                                     assert(ios.width() == 0);
   1602                                 }
   1603                                 ios.width(25);
   1604                                 internal(ios);
   1605                                 {
   1606                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1607                                     std::string ex(str, iter.base());
   1608                                     assert(ex == "************************0");
   1609                                     assert(ios.width() == 0);
   1610                                 }
   1611                             }
   1612                         }
   1613                         showpoint(ios);
   1614                         {
   1615                             ios.imbue(lc);
   1616                             {
   1617                                 ios.width(0);
   1618                                 {
   1619                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1620                                     std::string ex(str, iter.base());
   1621                                     assert(ex == "0.00000");
   1622                                     assert(ios.width() == 0);
   1623                                 }
   1624                                 ios.width(25);
   1625                                 left(ios);
   1626                                 {
   1627                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1628                                     std::string ex(str, iter.base());
   1629                                     assert(ex == "0.00000******************");
   1630                                     assert(ios.width() == 0);
   1631                                 }
   1632                                 ios.width(25);
   1633                                 right(ios);
   1634                                 {
   1635                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1636                                     std::string ex(str, iter.base());
   1637                                     assert(ex == "******************0.00000");
   1638                                     assert(ios.width() == 0);
   1639                                 }
   1640                                 ios.width(25);
   1641                                 internal(ios);
   1642                                 {
   1643                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1644                                     std::string ex(str, iter.base());
   1645                                     assert(ex == "******************0.00000");
   1646                                     assert(ios.width() == 0);
   1647                                 }
   1648                             }
   1649                             ios.imbue(lg);
   1650                             {
   1651                                 ios.width(0);
   1652                                 {
   1653                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1654                                     std::string ex(str, iter.base());
   1655                                     assert(ex == "0;00000");
   1656                                     assert(ios.width() == 0);
   1657                                 }
   1658                                 ios.width(25);
   1659                                 left(ios);
   1660                                 {
   1661                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1662                                     std::string ex(str, iter.base());
   1663                                     assert(ex == "0;00000******************");
   1664                                     assert(ios.width() == 0);
   1665                                 }
   1666                                 ios.width(25);
   1667                                 right(ios);
   1668                                 {
   1669                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1670                                     std::string ex(str, iter.base());
   1671                                     assert(ex == "******************0;00000");
   1672                                     assert(ios.width() == 0);
   1673                                 }
   1674                                 ios.width(25);
   1675                                 internal(ios);
   1676                                 {
   1677                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1678                                     std::string ex(str, iter.base());
   1679                                     assert(ex == "******************0;00000");
   1680                                     assert(ios.width() == 0);
   1681                                 }
   1682                             }
   1683                         }
   1684                     }
   1685                     showpos(ios);
   1686                     {
   1687                         noshowpoint(ios);
   1688                         {
   1689                             ios.imbue(lc);
   1690                             {
   1691                                 ios.width(0);
   1692                                 {
   1693                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1694                                     std::string ex(str, iter.base());
   1695                                     assert(ex == "+0");
   1696                                     assert(ios.width() == 0);
   1697                                 }
   1698                                 ios.width(25);
   1699                                 left(ios);
   1700                                 {
   1701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1702                                     std::string ex(str, iter.base());
   1703                                     assert(ex == "+0***********************");
   1704                                     assert(ios.width() == 0);
   1705                                 }
   1706                                 ios.width(25);
   1707                                 right(ios);
   1708                                 {
   1709                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1710                                     std::string ex(str, iter.base());
   1711                                     assert(ex == "***********************+0");
   1712                                     assert(ios.width() == 0);
   1713                                 }
   1714                                 ios.width(25);
   1715                                 internal(ios);
   1716                                 {
   1717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1718                                     std::string ex(str, iter.base());
   1719                                     assert(ex == "+***********************0");
   1720                                     assert(ios.width() == 0);
   1721                                 }
   1722                             }
   1723                             ios.imbue(lg);
   1724                             {
   1725                                 ios.width(0);
   1726                                 {
   1727                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1728                                     std::string ex(str, iter.base());
   1729                                     assert(ex == "+0");
   1730                                     assert(ios.width() == 0);
   1731                                 }
   1732                                 ios.width(25);
   1733                                 left(ios);
   1734                                 {
   1735                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1736                                     std::string ex(str, iter.base());
   1737                                     assert(ex == "+0***********************");
   1738                                     assert(ios.width() == 0);
   1739                                 }
   1740                                 ios.width(25);
   1741                                 right(ios);
   1742                                 {
   1743                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1744                                     std::string ex(str, iter.base());
   1745                                     assert(ex == "***********************+0");
   1746                                     assert(ios.width() == 0);
   1747                                 }
   1748                                 ios.width(25);
   1749                                 internal(ios);
   1750                                 {
   1751                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1752                                     std::string ex(str, iter.base());
   1753                                     assert(ex == "+***********************0");
   1754                                     assert(ios.width() == 0);
   1755                                 }
   1756                             }
   1757                         }
   1758                         showpoint(ios);
   1759                         {
   1760                             ios.imbue(lc);
   1761                             {
   1762                                 ios.width(0);
   1763                                 {
   1764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1765                                     std::string ex(str, iter.base());
   1766                                     assert(ex == "+0.00000");
   1767                                     assert(ios.width() == 0);
   1768                                 }
   1769                                 ios.width(25);
   1770                                 left(ios);
   1771                                 {
   1772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1773                                     std::string ex(str, iter.base());
   1774                                     assert(ex == "+0.00000*****************");
   1775                                     assert(ios.width() == 0);
   1776                                 }
   1777                                 ios.width(25);
   1778                                 right(ios);
   1779                                 {
   1780                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1781                                     std::string ex(str, iter.base());
   1782                                     assert(ex == "*****************+0.00000");
   1783                                     assert(ios.width() == 0);
   1784                                 }
   1785                                 ios.width(25);
   1786                                 internal(ios);
   1787                                 {
   1788                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1789                                     std::string ex(str, iter.base());
   1790                                     assert(ex == "+*****************0.00000");
   1791                                     assert(ios.width() == 0);
   1792                                 }
   1793                             }
   1794                             ios.imbue(lg);
   1795                             {
   1796                                 ios.width(0);
   1797                                 {
   1798                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1799                                     std::string ex(str, iter.base());
   1800                                     assert(ex == "+0;00000");
   1801                                     assert(ios.width() == 0);
   1802                                 }
   1803                                 ios.width(25);
   1804                                 left(ios);
   1805                                 {
   1806                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1807                                     std::string ex(str, iter.base());
   1808                                     assert(ex == "+0;00000*****************");
   1809                                     assert(ios.width() == 0);
   1810                                 }
   1811                                 ios.width(25);
   1812                                 right(ios);
   1813                                 {
   1814                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1815                                     std::string ex(str, iter.base());
   1816                                     assert(ex == "*****************+0;00000");
   1817                                     assert(ios.width() == 0);
   1818                                 }
   1819                                 ios.width(25);
   1820                                 internal(ios);
   1821                                 {
   1822                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1823                                     std::string ex(str, iter.base());
   1824                                     assert(ex == "+*****************0;00000");
   1825                                     assert(ios.width() == 0);
   1826                                 }
   1827                             }
   1828                         }
   1829                     }
   1830                 }
   1831             }
   1832             ios.precision(16);
   1833             {
   1834                 nouppercase(ios);
   1835                 {
   1836                     noshowpos(ios);
   1837                     {
   1838                         noshowpoint(ios);
   1839                         {
   1840                             ios.imbue(lc);
   1841                             {
   1842                                 ios.width(0);
   1843                                 {
   1844                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1845                                     std::string ex(str, iter.base());
   1846                                     assert(ex == "0");
   1847                                     assert(ios.width() == 0);
   1848                                 }
   1849                                 ios.width(25);
   1850                                 left(ios);
   1851                                 {
   1852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1853                                     std::string ex(str, iter.base());
   1854                                     assert(ex == "0************************");
   1855                                     assert(ios.width() == 0);
   1856                                 }
   1857                                 ios.width(25);
   1858                                 right(ios);
   1859                                 {
   1860                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1861                                     std::string ex(str, iter.base());
   1862                                     assert(ex == "************************0");
   1863                                     assert(ios.width() == 0);
   1864                                 }
   1865                                 ios.width(25);
   1866                                 internal(ios);
   1867                                 {
   1868                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1869                                     std::string ex(str, iter.base());
   1870                                     assert(ex == "************************0");
   1871                                     assert(ios.width() == 0);
   1872                                 }
   1873                             }
   1874                             ios.imbue(lg);
   1875                             {
   1876                                 ios.width(0);
   1877                                 {
   1878                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1879                                     std::string ex(str, iter.base());
   1880                                     assert(ex == "0");
   1881                                     assert(ios.width() == 0);
   1882                                 }
   1883                                 ios.width(25);
   1884                                 left(ios);
   1885                                 {
   1886                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1887                                     std::string ex(str, iter.base());
   1888                                     assert(ex == "0************************");
   1889                                     assert(ios.width() == 0);
   1890                                 }
   1891                                 ios.width(25);
   1892                                 right(ios);
   1893                                 {
   1894                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1895                                     std::string ex(str, iter.base());
   1896                                     assert(ex == "************************0");
   1897                                     assert(ios.width() == 0);
   1898                                 }
   1899                                 ios.width(25);
   1900                                 internal(ios);
   1901                                 {
   1902                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1903                                     std::string ex(str, iter.base());
   1904                                     assert(ex == "************************0");
   1905                                     assert(ios.width() == 0);
   1906                                 }
   1907                             }
   1908                         }
   1909                         showpoint(ios);
   1910                         {
   1911                             ios.imbue(lc);
   1912                             {
   1913                                 ios.width(0);
   1914                                 {
   1915                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1916                                     std::string ex(str, iter.base());
   1917                                     assert(ex == "0.000000000000000");
   1918                                     assert(ios.width() == 0);
   1919                                 }
   1920                                 ios.width(25);
   1921                                 left(ios);
   1922                                 {
   1923                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1924                                     std::string ex(str, iter.base());
   1925                                     assert(ex == "0.000000000000000********");
   1926                                     assert(ios.width() == 0);
   1927                                 }
   1928                                 ios.width(25);
   1929                                 right(ios);
   1930                                 {
   1931                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1932                                     std::string ex(str, iter.base());
   1933                                     assert(ex == "********0.000000000000000");
   1934                                     assert(ios.width() == 0);
   1935                                 }
   1936                                 ios.width(25);
   1937                                 internal(ios);
   1938                                 {
   1939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1940                                     std::string ex(str, iter.base());
   1941                                     assert(ex == "********0.000000000000000");
   1942                                     assert(ios.width() == 0);
   1943                                 }
   1944                             }
   1945                             ios.imbue(lg);
   1946                             {
   1947                                 ios.width(0);
   1948                                 {
   1949                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1950                                     std::string ex(str, iter.base());
   1951                                     assert(ex == "0;000000000000000");
   1952                                     assert(ios.width() == 0);
   1953                                 }
   1954                                 ios.width(25);
   1955                                 left(ios);
   1956                                 {
   1957                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1958                                     std::string ex(str, iter.base());
   1959                                     assert(ex == "0;000000000000000********");
   1960                                     assert(ios.width() == 0);
   1961                                 }
   1962                                 ios.width(25);
   1963                                 right(ios);
   1964                                 {
   1965                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1966                                     std::string ex(str, iter.base());
   1967                                     assert(ex == "********0;000000000000000");
   1968                                     assert(ios.width() == 0);
   1969                                 }
   1970                                 ios.width(25);
   1971                                 internal(ios);
   1972                                 {
   1973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1974                                     std::string ex(str, iter.base());
   1975                                     assert(ex == "********0;000000000000000");
   1976                                     assert(ios.width() == 0);
   1977                                 }
   1978                             }
   1979                         }
   1980                     }
   1981                     showpos(ios);
   1982                     {
   1983                         noshowpoint(ios);
   1984                         {
   1985                             ios.imbue(lc);
   1986                             {
   1987                                 ios.width(0);
   1988                                 {
   1989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1990                                     std::string ex(str, iter.base());
   1991                                     assert(ex == "+0");
   1992                                     assert(ios.width() == 0);
   1993                                 }
   1994                                 ios.width(25);
   1995                                 left(ios);
   1996                                 {
   1997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   1998                                     std::string ex(str, iter.base());
   1999                                     assert(ex == "+0***********************");
   2000                                     assert(ios.width() == 0);
   2001                                 }
   2002                                 ios.width(25);
   2003                                 right(ios);
   2004                                 {
   2005                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2006                                     std::string ex(str, iter.base());
   2007                                     assert(ex == "***********************+0");
   2008                                     assert(ios.width() == 0);
   2009                                 }
   2010                                 ios.width(25);
   2011                                 internal(ios);
   2012                                 {
   2013                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2014                                     std::string ex(str, iter.base());
   2015                                     assert(ex == "+***********************0");
   2016                                     assert(ios.width() == 0);
   2017                                 }
   2018                             }
   2019                             ios.imbue(lg);
   2020                             {
   2021                                 ios.width(0);
   2022                                 {
   2023                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2024                                     std::string ex(str, iter.base());
   2025                                     assert(ex == "+0");
   2026                                     assert(ios.width() == 0);
   2027                                 }
   2028                                 ios.width(25);
   2029                                 left(ios);
   2030                                 {
   2031                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2032                                     std::string ex(str, iter.base());
   2033                                     assert(ex == "+0***********************");
   2034                                     assert(ios.width() == 0);
   2035                                 }
   2036                                 ios.width(25);
   2037                                 right(ios);
   2038                                 {
   2039                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2040                                     std::string ex(str, iter.base());
   2041                                     assert(ex == "***********************+0");
   2042                                     assert(ios.width() == 0);
   2043                                 }
   2044                                 ios.width(25);
   2045                                 internal(ios);
   2046                                 {
   2047                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2048                                     std::string ex(str, iter.base());
   2049                                     assert(ex == "+***********************0");
   2050                                     assert(ios.width() == 0);
   2051                                 }
   2052                             }
   2053                         }
   2054                         showpoint(ios);
   2055                         {
   2056                             ios.imbue(lc);
   2057                             {
   2058                                 ios.width(0);
   2059                                 {
   2060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2061                                     std::string ex(str, iter.base());
   2062                                     assert(ex == "+0.000000000000000");
   2063                                     assert(ios.width() == 0);
   2064                                 }
   2065                                 ios.width(25);
   2066                                 left(ios);
   2067                                 {
   2068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2069                                     std::string ex(str, iter.base());
   2070                                     assert(ex == "+0.000000000000000*******");
   2071                                     assert(ios.width() == 0);
   2072                                 }
   2073                                 ios.width(25);
   2074                                 right(ios);
   2075                                 {
   2076                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2077                                     std::string ex(str, iter.base());
   2078                                     assert(ex == "*******+0.000000000000000");
   2079                                     assert(ios.width() == 0);
   2080                                 }
   2081                                 ios.width(25);
   2082                                 internal(ios);
   2083                                 {
   2084                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2085                                     std::string ex(str, iter.base());
   2086                                     assert(ex == "+*******0.000000000000000");
   2087                                     assert(ios.width() == 0);
   2088                                 }
   2089                             }
   2090                             ios.imbue(lg);
   2091                             {
   2092                                 ios.width(0);
   2093                                 {
   2094                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2095                                     std::string ex(str, iter.base());
   2096                                     assert(ex == "+0;000000000000000");
   2097                                     assert(ios.width() == 0);
   2098                                 }
   2099                                 ios.width(25);
   2100                                 left(ios);
   2101                                 {
   2102                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2103                                     std::string ex(str, iter.base());
   2104                                     assert(ex == "+0;000000000000000*******");
   2105                                     assert(ios.width() == 0);
   2106                                 }
   2107                                 ios.width(25);
   2108                                 right(ios);
   2109                                 {
   2110                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2111                                     std::string ex(str, iter.base());
   2112                                     assert(ex == "*******+0;000000000000000");
   2113                                     assert(ios.width() == 0);
   2114                                 }
   2115                                 ios.width(25);
   2116                                 internal(ios);
   2117                                 {
   2118                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2119                                     std::string ex(str, iter.base());
   2120                                     assert(ex == "+*******0;000000000000000");
   2121                                     assert(ios.width() == 0);
   2122                                 }
   2123                             }
   2124                         }
   2125                     }
   2126                 }
   2127                 uppercase(ios);
   2128                 {
   2129                     noshowpos(ios);
   2130                     {
   2131                         noshowpoint(ios);
   2132                         {
   2133                             ios.imbue(lc);
   2134                             {
   2135                                 ios.width(0);
   2136                                 {
   2137                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2138                                     std::string ex(str, iter.base());
   2139                                     assert(ex == "0");
   2140                                     assert(ios.width() == 0);
   2141                                 }
   2142                                 ios.width(25);
   2143                                 left(ios);
   2144                                 {
   2145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2146                                     std::string ex(str, iter.base());
   2147                                     assert(ex == "0************************");
   2148                                     assert(ios.width() == 0);
   2149                                 }
   2150                                 ios.width(25);
   2151                                 right(ios);
   2152                                 {
   2153                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2154                                     std::string ex(str, iter.base());
   2155                                     assert(ex == "************************0");
   2156                                     assert(ios.width() == 0);
   2157                                 }
   2158                                 ios.width(25);
   2159                                 internal(ios);
   2160                                 {
   2161                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2162                                     std::string ex(str, iter.base());
   2163                                     assert(ex == "************************0");
   2164                                     assert(ios.width() == 0);
   2165                                 }
   2166                             }
   2167                             ios.imbue(lg);
   2168                             {
   2169                                 ios.width(0);
   2170                                 {
   2171                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2172                                     std::string ex(str, iter.base());
   2173                                     assert(ex == "0");
   2174                                     assert(ios.width() == 0);
   2175                                 }
   2176                                 ios.width(25);
   2177                                 left(ios);
   2178                                 {
   2179                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2180                                     std::string ex(str, iter.base());
   2181                                     assert(ex == "0************************");
   2182                                     assert(ios.width() == 0);
   2183                                 }
   2184                                 ios.width(25);
   2185                                 right(ios);
   2186                                 {
   2187                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2188                                     std::string ex(str, iter.base());
   2189                                     assert(ex == "************************0");
   2190                                     assert(ios.width() == 0);
   2191                                 }
   2192                                 ios.width(25);
   2193                                 internal(ios);
   2194                                 {
   2195                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2196                                     std::string ex(str, iter.base());
   2197                                     assert(ex == "************************0");
   2198                                     assert(ios.width() == 0);
   2199                                 }
   2200                             }
   2201                         }
   2202                         showpoint(ios);
   2203                         {
   2204                             ios.imbue(lc);
   2205                             {
   2206                                 ios.width(0);
   2207                                 {
   2208                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2209                                     std::string ex(str, iter.base());
   2210                                     assert(ex == "0.000000000000000");
   2211                                     assert(ios.width() == 0);
   2212                                 }
   2213                                 ios.width(25);
   2214                                 left(ios);
   2215                                 {
   2216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2217                                     std::string ex(str, iter.base());
   2218                                     assert(ex == "0.000000000000000********");
   2219                                     assert(ios.width() == 0);
   2220                                 }
   2221                                 ios.width(25);
   2222                                 right(ios);
   2223                                 {
   2224                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2225                                     std::string ex(str, iter.base());
   2226                                     assert(ex == "********0.000000000000000");
   2227                                     assert(ios.width() == 0);
   2228                                 }
   2229                                 ios.width(25);
   2230                                 internal(ios);
   2231                                 {
   2232                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2233                                     std::string ex(str, iter.base());
   2234                                     assert(ex == "********0.000000000000000");
   2235                                     assert(ios.width() == 0);
   2236                                 }
   2237                             }
   2238                             ios.imbue(lg);
   2239                             {
   2240                                 ios.width(0);
   2241                                 {
   2242                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2243                                     std::string ex(str, iter.base());
   2244                                     assert(ex == "0;000000000000000");
   2245                                     assert(ios.width() == 0);
   2246                                 }
   2247                                 ios.width(25);
   2248                                 left(ios);
   2249                                 {
   2250                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2251                                     std::string ex(str, iter.base());
   2252                                     assert(ex == "0;000000000000000********");
   2253                                     assert(ios.width() == 0);
   2254                                 }
   2255                                 ios.width(25);
   2256                                 right(ios);
   2257                                 {
   2258                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2259                                     std::string ex(str, iter.base());
   2260                                     assert(ex == "********0;000000000000000");
   2261                                     assert(ios.width() == 0);
   2262                                 }
   2263                                 ios.width(25);
   2264                                 internal(ios);
   2265                                 {
   2266                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2267                                     std::string ex(str, iter.base());
   2268                                     assert(ex == "********0;000000000000000");
   2269                                     assert(ios.width() == 0);
   2270                                 }
   2271                             }
   2272                         }
   2273                     }
   2274                     showpos(ios);
   2275                     {
   2276                         noshowpoint(ios);
   2277                         {
   2278                             ios.imbue(lc);
   2279                             {
   2280                                 ios.width(0);
   2281                                 {
   2282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2283                                     std::string ex(str, iter.base());
   2284                                     assert(ex == "+0");
   2285                                     assert(ios.width() == 0);
   2286                                 }
   2287                                 ios.width(25);
   2288                                 left(ios);
   2289                                 {
   2290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2291                                     std::string ex(str, iter.base());
   2292                                     assert(ex == "+0***********************");
   2293                                     assert(ios.width() == 0);
   2294                                 }
   2295                                 ios.width(25);
   2296                                 right(ios);
   2297                                 {
   2298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2299                                     std::string ex(str, iter.base());
   2300                                     assert(ex == "***********************+0");
   2301                                     assert(ios.width() == 0);
   2302                                 }
   2303                                 ios.width(25);
   2304                                 internal(ios);
   2305                                 {
   2306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2307                                     std::string ex(str, iter.base());
   2308                                     assert(ex == "+***********************0");
   2309                                     assert(ios.width() == 0);
   2310                                 }
   2311                             }
   2312                             ios.imbue(lg);
   2313                             {
   2314                                 ios.width(0);
   2315                                 {
   2316                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2317                                     std::string ex(str, iter.base());
   2318                                     assert(ex == "+0");
   2319                                     assert(ios.width() == 0);
   2320                                 }
   2321                                 ios.width(25);
   2322                                 left(ios);
   2323                                 {
   2324                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2325                                     std::string ex(str, iter.base());
   2326                                     assert(ex == "+0***********************");
   2327                                     assert(ios.width() == 0);
   2328                                 }
   2329                                 ios.width(25);
   2330                                 right(ios);
   2331                                 {
   2332                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2333                                     std::string ex(str, iter.base());
   2334                                     assert(ex == "***********************+0");
   2335                                     assert(ios.width() == 0);
   2336                                 }
   2337                                 ios.width(25);
   2338                                 internal(ios);
   2339                                 {
   2340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2341                                     std::string ex(str, iter.base());
   2342                                     assert(ex == "+***********************0");
   2343                                     assert(ios.width() == 0);
   2344                                 }
   2345                             }
   2346                         }
   2347                         showpoint(ios);
   2348                         {
   2349                             ios.imbue(lc);
   2350                             {
   2351                                 ios.width(0);
   2352                                 {
   2353                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2354                                     std::string ex(str, iter.base());
   2355                                     assert(ex == "+0.000000000000000");
   2356                                     assert(ios.width() == 0);
   2357                                 }
   2358                                 ios.width(25);
   2359                                 left(ios);
   2360                                 {
   2361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2362                                     std::string ex(str, iter.base());
   2363                                     assert(ex == "+0.000000000000000*******");
   2364                                     assert(ios.width() == 0);
   2365                                 }
   2366                                 ios.width(25);
   2367                                 right(ios);
   2368                                 {
   2369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2370                                     std::string ex(str, iter.base());
   2371                                     assert(ex == "*******+0.000000000000000");
   2372                                     assert(ios.width() == 0);
   2373                                 }
   2374                                 ios.width(25);
   2375                                 internal(ios);
   2376                                 {
   2377                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2378                                     std::string ex(str, iter.base());
   2379                                     assert(ex == "+*******0.000000000000000");
   2380                                     assert(ios.width() == 0);
   2381                                 }
   2382                             }
   2383                             ios.imbue(lg);
   2384                             {
   2385                                 ios.width(0);
   2386                                 {
   2387                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2388                                     std::string ex(str, iter.base());
   2389                                     assert(ex == "+0;000000000000000");
   2390                                     assert(ios.width() == 0);
   2391                                 }
   2392                                 ios.width(25);
   2393                                 left(ios);
   2394                                 {
   2395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2396                                     std::string ex(str, iter.base());
   2397                                     assert(ex == "+0;000000000000000*******");
   2398                                     assert(ios.width() == 0);
   2399                                 }
   2400                                 ios.width(25);
   2401                                 right(ios);
   2402                                 {
   2403                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2404                                     std::string ex(str, iter.base());
   2405                                     assert(ex == "*******+0;000000000000000");
   2406                                     assert(ios.width() == 0);
   2407                                 }
   2408                                 ios.width(25);
   2409                                 internal(ios);
   2410                                 {
   2411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2412                                     std::string ex(str, iter.base());
   2413                                     assert(ex == "+*******0;000000000000000");
   2414                                     assert(ios.width() == 0);
   2415                                 }
   2416                             }
   2417                         }
   2418                     }
   2419                 }
   2420             }
   2421             ios.precision(60);
   2422             {
   2423                 nouppercase(ios);
   2424                 {
   2425                     noshowpos(ios);
   2426                     {
   2427                         noshowpoint(ios);
   2428                         {
   2429                             ios.imbue(lc);
   2430                             {
   2431                                 ios.width(0);
   2432                                 {
   2433                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2434                                     std::string ex(str, iter.base());
   2435                                     assert(ex == "0");
   2436                                     assert(ios.width() == 0);
   2437                                 }
   2438                                 ios.width(25);
   2439                                 left(ios);
   2440                                 {
   2441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2442                                     std::string ex(str, iter.base());
   2443                                     assert(ex == "0************************");
   2444                                     assert(ios.width() == 0);
   2445                                 }
   2446                                 ios.width(25);
   2447                                 right(ios);
   2448                                 {
   2449                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2450                                     std::string ex(str, iter.base());
   2451                                     assert(ex == "************************0");
   2452                                     assert(ios.width() == 0);
   2453                                 }
   2454                                 ios.width(25);
   2455                                 internal(ios);
   2456                                 {
   2457                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2458                                     std::string ex(str, iter.base());
   2459                                     assert(ex == "************************0");
   2460                                     assert(ios.width() == 0);
   2461                                 }
   2462                             }
   2463                             ios.imbue(lg);
   2464                             {
   2465                                 ios.width(0);
   2466                                 {
   2467                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2468                                     std::string ex(str, iter.base());
   2469                                     assert(ex == "0");
   2470                                     assert(ios.width() == 0);
   2471                                 }
   2472                                 ios.width(25);
   2473                                 left(ios);
   2474                                 {
   2475                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2476                                     std::string ex(str, iter.base());
   2477                                     assert(ex == "0************************");
   2478                                     assert(ios.width() == 0);
   2479                                 }
   2480                                 ios.width(25);
   2481                                 right(ios);
   2482                                 {
   2483                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2484                                     std::string ex(str, iter.base());
   2485                                     assert(ex == "************************0");
   2486                                     assert(ios.width() == 0);
   2487                                 }
   2488                                 ios.width(25);
   2489                                 internal(ios);
   2490                                 {
   2491                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2492                                     std::string ex(str, iter.base());
   2493                                     assert(ex == "************************0");
   2494                                     assert(ios.width() == 0);
   2495                                 }
   2496                             }
   2497                         }
   2498                         showpoint(ios);
   2499                         {
   2500                             ios.imbue(lc);
   2501                             {
   2502                                 ios.width(0);
   2503                                 {
   2504                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2505                                     std::string ex(str, iter.base());
   2506                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2507                                     assert(ios.width() == 0);
   2508                                 }
   2509                                 ios.width(25);
   2510                                 left(ios);
   2511                                 {
   2512                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2513                                     std::string ex(str, iter.base());
   2514                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2515                                     assert(ios.width() == 0);
   2516                                 }
   2517                                 ios.width(25);
   2518                                 right(ios);
   2519                                 {
   2520                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2521                                     std::string ex(str, iter.base());
   2522                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2523                                     assert(ios.width() == 0);
   2524                                 }
   2525                                 ios.width(25);
   2526                                 internal(ios);
   2527                                 {
   2528                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2529                                     std::string ex(str, iter.base());
   2530                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2531                                     assert(ios.width() == 0);
   2532                                 }
   2533                             }
   2534                             ios.imbue(lg);
   2535                             {
   2536                                 ios.width(0);
   2537                                 {
   2538                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2539                                     std::string ex(str, iter.base());
   2540                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2541                                     assert(ios.width() == 0);
   2542                                 }
   2543                                 ios.width(25);
   2544                                 left(ios);
   2545                                 {
   2546                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2547                                     std::string ex(str, iter.base());
   2548                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2549                                     assert(ios.width() == 0);
   2550                                 }
   2551                                 ios.width(25);
   2552                                 right(ios);
   2553                                 {
   2554                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2555                                     std::string ex(str, iter.base());
   2556                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2557                                     assert(ios.width() == 0);
   2558                                 }
   2559                                 ios.width(25);
   2560                                 internal(ios);
   2561                                 {
   2562                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2563                                     std::string ex(str, iter.base());
   2564                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2565                                     assert(ios.width() == 0);
   2566                                 }
   2567                             }
   2568                         }
   2569                     }
   2570                     showpos(ios);
   2571                     {
   2572                         noshowpoint(ios);
   2573                         {
   2574                             ios.imbue(lc);
   2575                             {
   2576                                 ios.width(0);
   2577                                 {
   2578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2579                                     std::string ex(str, iter.base());
   2580                                     assert(ex == "+0");
   2581                                     assert(ios.width() == 0);
   2582                                 }
   2583                                 ios.width(25);
   2584                                 left(ios);
   2585                                 {
   2586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2587                                     std::string ex(str, iter.base());
   2588                                     assert(ex == "+0***********************");
   2589                                     assert(ios.width() == 0);
   2590                                 }
   2591                                 ios.width(25);
   2592                                 right(ios);
   2593                                 {
   2594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2595                                     std::string ex(str, iter.base());
   2596                                     assert(ex == "***********************+0");
   2597                                     assert(ios.width() == 0);
   2598                                 }
   2599                                 ios.width(25);
   2600                                 internal(ios);
   2601                                 {
   2602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2603                                     std::string ex(str, iter.base());
   2604                                     assert(ex == "+***********************0");
   2605                                     assert(ios.width() == 0);
   2606                                 }
   2607                             }
   2608                             ios.imbue(lg);
   2609                             {
   2610                                 ios.width(0);
   2611                                 {
   2612                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2613                                     std::string ex(str, iter.base());
   2614                                     assert(ex == "+0");
   2615                                     assert(ios.width() == 0);
   2616                                 }
   2617                                 ios.width(25);
   2618                                 left(ios);
   2619                                 {
   2620                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2621                                     std::string ex(str, iter.base());
   2622                                     assert(ex == "+0***********************");
   2623                                     assert(ios.width() == 0);
   2624                                 }
   2625                                 ios.width(25);
   2626                                 right(ios);
   2627                                 {
   2628                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2629                                     std::string ex(str, iter.base());
   2630                                     assert(ex == "***********************+0");
   2631                                     assert(ios.width() == 0);
   2632                                 }
   2633                                 ios.width(25);
   2634                                 internal(ios);
   2635                                 {
   2636                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2637                                     std::string ex(str, iter.base());
   2638                                     assert(ex == "+***********************0");
   2639                                     assert(ios.width() == 0);
   2640                                 }
   2641                             }
   2642                         }
   2643                         showpoint(ios);
   2644                         {
   2645                             ios.imbue(lc);
   2646                             {
   2647                                 ios.width(0);
   2648                                 {
   2649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2650                                     std::string ex(str, iter.base());
   2651                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2652                                     assert(ios.width() == 0);
   2653                                 }
   2654                                 ios.width(25);
   2655                                 left(ios);
   2656                                 {
   2657                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2658                                     std::string ex(str, iter.base());
   2659                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2660                                     assert(ios.width() == 0);
   2661                                 }
   2662                                 ios.width(25);
   2663                                 right(ios);
   2664                                 {
   2665                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2666                                     std::string ex(str, iter.base());
   2667                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2668                                     assert(ios.width() == 0);
   2669                                 }
   2670                                 ios.width(25);
   2671                                 internal(ios);
   2672                                 {
   2673                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2674                                     std::string ex(str, iter.base());
   2675                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2676                                     assert(ios.width() == 0);
   2677                                 }
   2678                             }
   2679                             ios.imbue(lg);
   2680                             {
   2681                                 ios.width(0);
   2682                                 {
   2683                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2684                                     std::string ex(str, iter.base());
   2685                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2686                                     assert(ios.width() == 0);
   2687                                 }
   2688                                 ios.width(25);
   2689                                 left(ios);
   2690                                 {
   2691                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2692                                     std::string ex(str, iter.base());
   2693                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2694                                     assert(ios.width() == 0);
   2695                                 }
   2696                                 ios.width(25);
   2697                                 right(ios);
   2698                                 {
   2699                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2700                                     std::string ex(str, iter.base());
   2701                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2702                                     assert(ios.width() == 0);
   2703                                 }
   2704                                 ios.width(25);
   2705                                 internal(ios);
   2706                                 {
   2707                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2708                                     std::string ex(str, iter.base());
   2709                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2710                                     assert(ios.width() == 0);
   2711                                 }
   2712                             }
   2713                         }
   2714                     }
   2715                 }
   2716                 uppercase(ios);
   2717                 {
   2718                     noshowpos(ios);
   2719                     {
   2720                         noshowpoint(ios);
   2721                         {
   2722                             ios.imbue(lc);
   2723                             {
   2724                                 ios.width(0);
   2725                                 {
   2726                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2727                                     std::string ex(str, iter.base());
   2728                                     assert(ex == "0");
   2729                                     assert(ios.width() == 0);
   2730                                 }
   2731                                 ios.width(25);
   2732                                 left(ios);
   2733                                 {
   2734                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2735                                     std::string ex(str, iter.base());
   2736                                     assert(ex == "0************************");
   2737                                     assert(ios.width() == 0);
   2738                                 }
   2739                                 ios.width(25);
   2740                                 right(ios);
   2741                                 {
   2742                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2743                                     std::string ex(str, iter.base());
   2744                                     assert(ex == "************************0");
   2745                                     assert(ios.width() == 0);
   2746                                 }
   2747                                 ios.width(25);
   2748                                 internal(ios);
   2749                                 {
   2750                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2751                                     std::string ex(str, iter.base());
   2752                                     assert(ex == "************************0");
   2753                                     assert(ios.width() == 0);
   2754                                 }
   2755                             }
   2756                             ios.imbue(lg);
   2757                             {
   2758                                 ios.width(0);
   2759                                 {
   2760                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2761                                     std::string ex(str, iter.base());
   2762                                     assert(ex == "0");
   2763                                     assert(ios.width() == 0);
   2764                                 }
   2765                                 ios.width(25);
   2766                                 left(ios);
   2767                                 {
   2768                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2769                                     std::string ex(str, iter.base());
   2770                                     assert(ex == "0************************");
   2771                                     assert(ios.width() == 0);
   2772                                 }
   2773                                 ios.width(25);
   2774                                 right(ios);
   2775                                 {
   2776                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2777                                     std::string ex(str, iter.base());
   2778                                     assert(ex == "************************0");
   2779                                     assert(ios.width() == 0);
   2780                                 }
   2781                                 ios.width(25);
   2782                                 internal(ios);
   2783                                 {
   2784                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2785                                     std::string ex(str, iter.base());
   2786                                     assert(ex == "************************0");
   2787                                     assert(ios.width() == 0);
   2788                                 }
   2789                             }
   2790                         }
   2791                         showpoint(ios);
   2792                         {
   2793                             ios.imbue(lc);
   2794                             {
   2795                                 ios.width(0);
   2796                                 {
   2797                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2798                                     std::string ex(str, iter.base());
   2799                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2800                                     assert(ios.width() == 0);
   2801                                 }
   2802                                 ios.width(25);
   2803                                 left(ios);
   2804                                 {
   2805                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2806                                     std::string ex(str, iter.base());
   2807                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2808                                     assert(ios.width() == 0);
   2809                                 }
   2810                                 ios.width(25);
   2811                                 right(ios);
   2812                                 {
   2813                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2814                                     std::string ex(str, iter.base());
   2815                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2816                                     assert(ios.width() == 0);
   2817                                 }
   2818                                 ios.width(25);
   2819                                 internal(ios);
   2820                                 {
   2821                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2822                                     std::string ex(str, iter.base());
   2823                                     assert(ex == "0.00000000000000000000000000000000000000000000000000000000000");
   2824                                     assert(ios.width() == 0);
   2825                                 }
   2826                             }
   2827                             ios.imbue(lg);
   2828                             {
   2829                                 ios.width(0);
   2830                                 {
   2831                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2832                                     std::string ex(str, iter.base());
   2833                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2834                                     assert(ios.width() == 0);
   2835                                 }
   2836                                 ios.width(25);
   2837                                 left(ios);
   2838                                 {
   2839                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2840                                     std::string ex(str, iter.base());
   2841                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2842                                     assert(ios.width() == 0);
   2843                                 }
   2844                                 ios.width(25);
   2845                                 right(ios);
   2846                                 {
   2847                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2848                                     std::string ex(str, iter.base());
   2849                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2850                                     assert(ios.width() == 0);
   2851                                 }
   2852                                 ios.width(25);
   2853                                 internal(ios);
   2854                                 {
   2855                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2856                                     std::string ex(str, iter.base());
   2857                                     assert(ex == "0;00000000000000000000000000000000000000000000000000000000000");
   2858                                     assert(ios.width() == 0);
   2859                                 }
   2860                             }
   2861                         }
   2862                     }
   2863                     showpos(ios);
   2864                     {
   2865                         noshowpoint(ios);
   2866                         {
   2867                             ios.imbue(lc);
   2868                             {
   2869                                 ios.width(0);
   2870                                 {
   2871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2872                                     std::string ex(str, iter.base());
   2873                                     assert(ex == "+0");
   2874                                     assert(ios.width() == 0);
   2875                                 }
   2876                                 ios.width(25);
   2877                                 left(ios);
   2878                                 {
   2879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2880                                     std::string ex(str, iter.base());
   2881                                     assert(ex == "+0***********************");
   2882                                     assert(ios.width() == 0);
   2883                                 }
   2884                                 ios.width(25);
   2885                                 right(ios);
   2886                                 {
   2887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2888                                     std::string ex(str, iter.base());
   2889                                     assert(ex == "***********************+0");
   2890                                     assert(ios.width() == 0);
   2891                                 }
   2892                                 ios.width(25);
   2893                                 internal(ios);
   2894                                 {
   2895                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2896                                     std::string ex(str, iter.base());
   2897                                     assert(ex == "+***********************0");
   2898                                     assert(ios.width() == 0);
   2899                                 }
   2900                             }
   2901                             ios.imbue(lg);
   2902                             {
   2903                                 ios.width(0);
   2904                                 {
   2905                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2906                                     std::string ex(str, iter.base());
   2907                                     assert(ex == "+0");
   2908                                     assert(ios.width() == 0);
   2909                                 }
   2910                                 ios.width(25);
   2911                                 left(ios);
   2912                                 {
   2913                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2914                                     std::string ex(str, iter.base());
   2915                                     assert(ex == "+0***********************");
   2916                                     assert(ios.width() == 0);
   2917                                 }
   2918                                 ios.width(25);
   2919                                 right(ios);
   2920                                 {
   2921                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2922                                     std::string ex(str, iter.base());
   2923                                     assert(ex == "***********************+0");
   2924                                     assert(ios.width() == 0);
   2925                                 }
   2926                                 ios.width(25);
   2927                                 internal(ios);
   2928                                 {
   2929                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2930                                     std::string ex(str, iter.base());
   2931                                     assert(ex == "+***********************0");
   2932                                     assert(ios.width() == 0);
   2933                                 }
   2934                             }
   2935                         }
   2936                         showpoint(ios);
   2937                         {
   2938                             ios.imbue(lc);
   2939                             {
   2940                                 ios.width(0);
   2941                                 {
   2942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2943                                     std::string ex(str, iter.base());
   2944                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2945                                     assert(ios.width() == 0);
   2946                                 }
   2947                                 ios.width(25);
   2948                                 left(ios);
   2949                                 {
   2950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2951                                     std::string ex(str, iter.base());
   2952                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2953                                     assert(ios.width() == 0);
   2954                                 }
   2955                                 ios.width(25);
   2956                                 right(ios);
   2957                                 {
   2958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2959                                     std::string ex(str, iter.base());
   2960                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2961                                     assert(ios.width() == 0);
   2962                                 }
   2963                                 ios.width(25);
   2964                                 internal(ios);
   2965                                 {
   2966                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2967                                     std::string ex(str, iter.base());
   2968                                     assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000");
   2969                                     assert(ios.width() == 0);
   2970                                 }
   2971                             }
   2972                             ios.imbue(lg);
   2973                             {
   2974                                 ios.width(0);
   2975                                 {
   2976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2977                                     std::string ex(str, iter.base());
   2978                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2979                                     assert(ios.width() == 0);
   2980                                 }
   2981                                 ios.width(25);
   2982                                 left(ios);
   2983                                 {
   2984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2985                                     std::string ex(str, iter.base());
   2986                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2987                                     assert(ios.width() == 0);
   2988                                 }
   2989                                 ios.width(25);
   2990                                 right(ios);
   2991                                 {
   2992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   2993                                     std::string ex(str, iter.base());
   2994                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   2995                                     assert(ios.width() == 0);
   2996                                 }
   2997                                 ios.width(25);
   2998                                 internal(ios);
   2999                                 {
   3000                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3001                                     std::string ex(str, iter.base());
   3002                                     assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000");
   3003                                     assert(ios.width() == 0);
   3004                                 }
   3005                             }
   3006                         }
   3007                     }
   3008                 }
   3009             }
   3010         }
   3011     }
   3012 }
   3013 
   3014 void test2()
   3015 {
   3016     char str[200];
   3017     output_iterator<char*> iter;
   3018     std::locale lc = std::locale::classic();
   3019     std::locale lg(lc, new my_numpunct);
   3020     const my_facet f(1);
   3021     {
   3022         long double v = -0.;
   3023         std::ios ios(0);
   3024         // %g
   3025         {
   3026             ios.precision(0);
   3027             {
   3028                 nouppercase(ios);
   3029                 {
   3030                     noshowpos(ios);
   3031                     {
   3032                         noshowpoint(ios);
   3033                         {
   3034                             ios.imbue(lc);
   3035                             {
   3036                                 ios.width(0);
   3037                                 {
   3038                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3039                                     std::string ex(str, iter.base());
   3040                                     assert(ex == "-0");
   3041                                     assert(ios.width() == 0);
   3042                                 }
   3043                                 ios.width(25);
   3044                                 left(ios);
   3045                                 {
   3046                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3047                                     std::string ex(str, iter.base());
   3048                                     assert(ex == "-0***********************");
   3049                                     assert(ios.width() == 0);
   3050                                 }
   3051                                 ios.width(25);
   3052                                 right(ios);
   3053                                 {
   3054                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3055                                     std::string ex(str, iter.base());
   3056                                     assert(ex == "***********************-0");
   3057                                     assert(ios.width() == 0);
   3058                                 }
   3059                                 ios.width(25);
   3060                                 internal(ios);
   3061                                 {
   3062                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3063                                     std::string ex(str, iter.base());
   3064                                     assert(ex == "-***********************0");
   3065                                     assert(ios.width() == 0);
   3066                                 }
   3067                             }
   3068                             ios.imbue(lg);
   3069                             {
   3070                                 ios.width(0);
   3071                                 {
   3072                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3073                                     std::string ex(str, iter.base());
   3074                                     assert(ex == "-0");
   3075                                     assert(ios.width() == 0);
   3076                                 }
   3077                                 ios.width(25);
   3078                                 left(ios);
   3079                                 {
   3080                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3081                                     std::string ex(str, iter.base());
   3082                                     assert(ex == "-0***********************");
   3083                                     assert(ios.width() == 0);
   3084                                 }
   3085                                 ios.width(25);
   3086                                 right(ios);
   3087                                 {
   3088                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3089                                     std::string ex(str, iter.base());
   3090                                     assert(ex == "***********************-0");
   3091                                     assert(ios.width() == 0);
   3092                                 }
   3093                                 ios.width(25);
   3094                                 internal(ios);
   3095                                 {
   3096                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3097                                     std::string ex(str, iter.base());
   3098                                     assert(ex == "-***********************0");
   3099                                     assert(ios.width() == 0);
   3100                                 }
   3101                             }
   3102                         }
   3103                         showpoint(ios);
   3104                         {
   3105                             ios.imbue(lc);
   3106                             {
   3107                                 ios.width(0);
   3108                                 {
   3109                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3110                                     std::string ex(str, iter.base());
   3111                                     assert(ex == "-0.");
   3112                                     assert(ios.width() == 0);
   3113                                 }
   3114                                 ios.width(25);
   3115                                 left(ios);
   3116                                 {
   3117                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3118                                     std::string ex(str, iter.base());
   3119                                     assert(ex == "-0.**********************");
   3120                                     assert(ios.width() == 0);
   3121                                 }
   3122                                 ios.width(25);
   3123                                 right(ios);
   3124                                 {
   3125                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3126                                     std::string ex(str, iter.base());
   3127                                     assert(ex == "**********************-0.");
   3128                                     assert(ios.width() == 0);
   3129                                 }
   3130                                 ios.width(25);
   3131                                 internal(ios);
   3132                                 {
   3133                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3134                                     std::string ex(str, iter.base());
   3135                                     assert(ex == "-**********************0.");
   3136                                     assert(ios.width() == 0);
   3137                                 }
   3138                             }
   3139                             ios.imbue(lg);
   3140                             {
   3141                                 ios.width(0);
   3142                                 {
   3143                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3144                                     std::string ex(str, iter.base());
   3145                                     assert(ex == "-0;");
   3146                                     assert(ios.width() == 0);
   3147                                 }
   3148                                 ios.width(25);
   3149                                 left(ios);
   3150                                 {
   3151                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3152                                     std::string ex(str, iter.base());
   3153                                     assert(ex == "-0;**********************");
   3154                                     assert(ios.width() == 0);
   3155                                 }
   3156                                 ios.width(25);
   3157                                 right(ios);
   3158                                 {
   3159                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3160                                     std::string ex(str, iter.base());
   3161                                     assert(ex == "**********************-0;");
   3162                                     assert(ios.width() == 0);
   3163                                 }
   3164                                 ios.width(25);
   3165                                 internal(ios);
   3166                                 {
   3167                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3168                                     std::string ex(str, iter.base());
   3169                                     assert(ex == "-**********************0;");
   3170                                     assert(ios.width() == 0);
   3171                                 }
   3172                             }
   3173                         }
   3174                     }
   3175                     showpos(ios);
   3176                     {
   3177                         noshowpoint(ios);
   3178                         {
   3179                             ios.imbue(lc);
   3180                             {
   3181                                 ios.width(0);
   3182                                 {
   3183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3184                                     std::string ex(str, iter.base());
   3185                                     assert(ex == "-0");
   3186                                     assert(ios.width() == 0);
   3187                                 }
   3188                                 ios.width(25);
   3189                                 left(ios);
   3190                                 {
   3191                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3192                                     std::string ex(str, iter.base());
   3193                                     assert(ex == "-0***********************");
   3194                                     assert(ios.width() == 0);
   3195                                 }
   3196                                 ios.width(25);
   3197                                 right(ios);
   3198                                 {
   3199                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3200                                     std::string ex(str, iter.base());
   3201                                     assert(ex == "***********************-0");
   3202                                     assert(ios.width() == 0);
   3203                                 }
   3204                                 ios.width(25);
   3205                                 internal(ios);
   3206                                 {
   3207                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3208                                     std::string ex(str, iter.base());
   3209                                     assert(ex == "-***********************0");
   3210                                     assert(ios.width() == 0);
   3211                                 }
   3212                             }
   3213                             ios.imbue(lg);
   3214                             {
   3215                                 ios.width(0);
   3216                                 {
   3217                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3218                                     std::string ex(str, iter.base());
   3219                                     assert(ex == "-0");
   3220                                     assert(ios.width() == 0);
   3221                                 }
   3222                                 ios.width(25);
   3223                                 left(ios);
   3224                                 {
   3225                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3226                                     std::string ex(str, iter.base());
   3227                                     assert(ex == "-0***********************");
   3228                                     assert(ios.width() == 0);
   3229                                 }
   3230                                 ios.width(25);
   3231                                 right(ios);
   3232                                 {
   3233                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3234                                     std::string ex(str, iter.base());
   3235                                     assert(ex == "***********************-0");
   3236                                     assert(ios.width() == 0);
   3237                                 }
   3238                                 ios.width(25);
   3239                                 internal(ios);
   3240                                 {
   3241                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3242                                     std::string ex(str, iter.base());
   3243                                     assert(ex == "-***********************0");
   3244                                     assert(ios.width() == 0);
   3245                                 }
   3246                             }
   3247                         }
   3248                         showpoint(ios);
   3249                         {
   3250                             ios.imbue(lc);
   3251                             {
   3252                                 ios.width(0);
   3253                                 {
   3254                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3255                                     std::string ex(str, iter.base());
   3256                                     assert(ex == "-0.");
   3257                                     assert(ios.width() == 0);
   3258                                 }
   3259                                 ios.width(25);
   3260                                 left(ios);
   3261                                 {
   3262                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3263                                     std::string ex(str, iter.base());
   3264                                     assert(ex == "-0.**********************");
   3265                                     assert(ios.width() == 0);
   3266                                 }
   3267                                 ios.width(25);
   3268                                 right(ios);
   3269                                 {
   3270                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3271                                     std::string ex(str, iter.base());
   3272                                     assert(ex == "**********************-0.");
   3273                                     assert(ios.width() == 0);
   3274                                 }
   3275                                 ios.width(25);
   3276                                 internal(ios);
   3277                                 {
   3278                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3279                                     std::string ex(str, iter.base());
   3280                                     assert(ex == "-**********************0.");
   3281                                     assert(ios.width() == 0);
   3282                                 }
   3283                             }
   3284                             ios.imbue(lg);
   3285                             {
   3286                                 ios.width(0);
   3287                                 {
   3288                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3289                                     std::string ex(str, iter.base());
   3290                                     assert(ex == "-0;");
   3291                                     assert(ios.width() == 0);
   3292                                 }
   3293                                 ios.width(25);
   3294                                 left(ios);
   3295                                 {
   3296                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3297                                     std::string ex(str, iter.base());
   3298                                     assert(ex == "-0;**********************");
   3299                                     assert(ios.width() == 0);
   3300                                 }
   3301                                 ios.width(25);
   3302                                 right(ios);
   3303                                 {
   3304                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3305                                     std::string ex(str, iter.base());
   3306                                     assert(ex == "**********************-0;");
   3307                                     assert(ios.width() == 0);
   3308                                 }
   3309                                 ios.width(25);
   3310                                 internal(ios);
   3311                                 {
   3312                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3313                                     std::string ex(str, iter.base());
   3314                                     assert(ex == "-**********************0;");
   3315                                     assert(ios.width() == 0);
   3316                                 }
   3317                             }
   3318                         }
   3319                     }
   3320                 }
   3321                 uppercase(ios);
   3322                 {
   3323                     noshowpos(ios);
   3324                     {
   3325                         noshowpoint(ios);
   3326                         {
   3327                             ios.imbue(lc);
   3328                             {
   3329                                 ios.width(0);
   3330                                 {
   3331                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3332                                     std::string ex(str, iter.base());
   3333                                     assert(ex == "-0");
   3334                                     assert(ios.width() == 0);
   3335                                 }
   3336                                 ios.width(25);
   3337                                 left(ios);
   3338                                 {
   3339                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3340                                     std::string ex(str, iter.base());
   3341                                     assert(ex == "-0***********************");
   3342                                     assert(ios.width() == 0);
   3343                                 }
   3344                                 ios.width(25);
   3345                                 right(ios);
   3346                                 {
   3347                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3348                                     std::string ex(str, iter.base());
   3349                                     assert(ex == "***********************-0");
   3350                                     assert(ios.width() == 0);
   3351                                 }
   3352                                 ios.width(25);
   3353                                 internal(ios);
   3354                                 {
   3355                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3356                                     std::string ex(str, iter.base());
   3357                                     assert(ex == "-***********************0");
   3358                                     assert(ios.width() == 0);
   3359                                 }
   3360                             }
   3361                             ios.imbue(lg);
   3362                             {
   3363                                 ios.width(0);
   3364                                 {
   3365                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3366                                     std::string ex(str, iter.base());
   3367                                     assert(ex == "-0");
   3368                                     assert(ios.width() == 0);
   3369                                 }
   3370                                 ios.width(25);
   3371                                 left(ios);
   3372                                 {
   3373                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3374                                     std::string ex(str, iter.base());
   3375                                     assert(ex == "-0***********************");
   3376                                     assert(ios.width() == 0);
   3377                                 }
   3378                                 ios.width(25);
   3379                                 right(ios);
   3380                                 {
   3381                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3382                                     std::string ex(str, iter.base());
   3383                                     assert(ex == "***********************-0");
   3384                                     assert(ios.width() == 0);
   3385                                 }
   3386                                 ios.width(25);
   3387                                 internal(ios);
   3388                                 {
   3389                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3390                                     std::string ex(str, iter.base());
   3391                                     assert(ex == "-***********************0");
   3392                                     assert(ios.width() == 0);
   3393                                 }
   3394                             }
   3395                         }
   3396                         showpoint(ios);
   3397                         {
   3398                             ios.imbue(lc);
   3399                             {
   3400                                 ios.width(0);
   3401                                 {
   3402                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3403                                     std::string ex(str, iter.base());
   3404                                     assert(ex == "-0.");
   3405                                     assert(ios.width() == 0);
   3406                                 }
   3407                                 ios.width(25);
   3408                                 left(ios);
   3409                                 {
   3410                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3411                                     std::string ex(str, iter.base());
   3412                                     assert(ex == "-0.**********************");
   3413                                     assert(ios.width() == 0);
   3414                                 }
   3415                                 ios.width(25);
   3416                                 right(ios);
   3417                                 {
   3418                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3419                                     std::string ex(str, iter.base());
   3420                                     assert(ex == "**********************-0.");
   3421                                     assert(ios.width() == 0);
   3422                                 }
   3423                                 ios.width(25);
   3424                                 internal(ios);
   3425                                 {
   3426                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3427                                     std::string ex(str, iter.base());
   3428                                     assert(ex == "-**********************0.");
   3429                                     assert(ios.width() == 0);
   3430                                 }
   3431                             }
   3432                             ios.imbue(lg);
   3433                             {
   3434                                 ios.width(0);
   3435                                 {
   3436                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3437                                     std::string ex(str, iter.base());
   3438                                     assert(ex == "-0;");
   3439                                     assert(ios.width() == 0);
   3440                                 }
   3441                                 ios.width(25);
   3442                                 left(ios);
   3443                                 {
   3444                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3445                                     std::string ex(str, iter.base());
   3446                                     assert(ex == "-0;**********************");
   3447                                     assert(ios.width() == 0);
   3448                                 }
   3449                                 ios.width(25);
   3450                                 right(ios);
   3451                                 {
   3452                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3453                                     std::string ex(str, iter.base());
   3454                                     assert(ex == "**********************-0;");
   3455                                     assert(ios.width() == 0);
   3456                                 }
   3457                                 ios.width(25);
   3458                                 internal(ios);
   3459                                 {
   3460                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3461                                     std::string ex(str, iter.base());
   3462                                     assert(ex == "-**********************0;");
   3463                                     assert(ios.width() == 0);
   3464                                 }
   3465                             }
   3466                         }
   3467                     }
   3468                     showpos(ios);
   3469                     {
   3470                         noshowpoint(ios);
   3471                         {
   3472                             ios.imbue(lc);
   3473                             {
   3474                                 ios.width(0);
   3475                                 {
   3476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3477                                     std::string ex(str, iter.base());
   3478                                     assert(ex == "-0");
   3479                                     assert(ios.width() == 0);
   3480                                 }
   3481                                 ios.width(25);
   3482                                 left(ios);
   3483                                 {
   3484                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3485                                     std::string ex(str, iter.base());
   3486                                     assert(ex == "-0***********************");
   3487                                     assert(ios.width() == 0);
   3488                                 }
   3489                                 ios.width(25);
   3490                                 right(ios);
   3491                                 {
   3492                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3493                                     std::string ex(str, iter.base());
   3494                                     assert(ex == "***********************-0");
   3495                                     assert(ios.width() == 0);
   3496                                 }
   3497                                 ios.width(25);
   3498                                 internal(ios);
   3499                                 {
   3500                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3501                                     std::string ex(str, iter.base());
   3502                                     assert(ex == "-***********************0");
   3503                                     assert(ios.width() == 0);
   3504                                 }
   3505                             }
   3506                             ios.imbue(lg);
   3507                             {
   3508                                 ios.width(0);
   3509                                 {
   3510                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3511                                     std::string ex(str, iter.base());
   3512                                     assert(ex == "-0");
   3513                                     assert(ios.width() == 0);
   3514                                 }
   3515                                 ios.width(25);
   3516                                 left(ios);
   3517                                 {
   3518                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3519                                     std::string ex(str, iter.base());
   3520                                     assert(ex == "-0***********************");
   3521                                     assert(ios.width() == 0);
   3522                                 }
   3523                                 ios.width(25);
   3524                                 right(ios);
   3525                                 {
   3526                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3527                                     std::string ex(str, iter.base());
   3528                                     assert(ex == "***********************-0");
   3529                                     assert(ios.width() == 0);
   3530                                 }
   3531                                 ios.width(25);
   3532                                 internal(ios);
   3533                                 {
   3534                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3535                                     std::string ex(str, iter.base());
   3536                                     assert(ex == "-***********************0");
   3537                                     assert(ios.width() == 0);
   3538                                 }
   3539                             }
   3540                         }
   3541                         showpoint(ios);
   3542                         {
   3543                             ios.imbue(lc);
   3544                             {
   3545                                 ios.width(0);
   3546                                 {
   3547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3548                                     std::string ex(str, iter.base());
   3549                                     assert(ex == "-0.");
   3550                                     assert(ios.width() == 0);
   3551                                 }
   3552                                 ios.width(25);
   3553                                 left(ios);
   3554                                 {
   3555                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3556                                     std::string ex(str, iter.base());
   3557                                     assert(ex == "-0.**********************");
   3558                                     assert(ios.width() == 0);
   3559                                 }
   3560                                 ios.width(25);
   3561                                 right(ios);
   3562                                 {
   3563                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3564                                     std::string ex(str, iter.base());
   3565                                     assert(ex == "**********************-0.");
   3566                                     assert(ios.width() == 0);
   3567                                 }
   3568                                 ios.width(25);
   3569                                 internal(ios);
   3570                                 {
   3571                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3572                                     std::string ex(str, iter.base());
   3573                                     assert(ex == "-**********************0.");
   3574                                     assert(ios.width() == 0);
   3575                                 }
   3576                             }
   3577                             ios.imbue(lg);
   3578                             {
   3579                                 ios.width(0);
   3580                                 {
   3581                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3582                                     std::string ex(str, iter.base());
   3583                                     assert(ex == "-0;");
   3584                                     assert(ios.width() == 0);
   3585                                 }
   3586                                 ios.width(25);
   3587                                 left(ios);
   3588                                 {
   3589                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3590                                     std::string ex(str, iter.base());
   3591                                     assert(ex == "-0;**********************");
   3592                                     assert(ios.width() == 0);
   3593                                 }
   3594                                 ios.width(25);
   3595                                 right(ios);
   3596                                 {
   3597                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3598                                     std::string ex(str, iter.base());
   3599                                     assert(ex == "**********************-0;");
   3600                                     assert(ios.width() == 0);
   3601                                 }
   3602                                 ios.width(25);
   3603                                 internal(ios);
   3604                                 {
   3605                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3606                                     std::string ex(str, iter.base());
   3607                                     assert(ex == "-**********************0;");
   3608                                     assert(ios.width() == 0);
   3609                                 }
   3610                             }
   3611                         }
   3612                     }
   3613                 }
   3614             }
   3615             ios.precision(1);
   3616             {
   3617                 nouppercase(ios);
   3618                 {
   3619                     noshowpos(ios);
   3620                     {
   3621                         noshowpoint(ios);
   3622                         {
   3623                             ios.imbue(lc);
   3624                             {
   3625                                 ios.width(0);
   3626                                 {
   3627                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3628                                     std::string ex(str, iter.base());
   3629                                     assert(ex == "-0");
   3630                                     assert(ios.width() == 0);
   3631                                 }
   3632                                 ios.width(25);
   3633                                 left(ios);
   3634                                 {
   3635                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3636                                     std::string ex(str, iter.base());
   3637                                     assert(ex == "-0***********************");
   3638                                     assert(ios.width() == 0);
   3639                                 }
   3640                                 ios.width(25);
   3641                                 right(ios);
   3642                                 {
   3643                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3644                                     std::string ex(str, iter.base());
   3645                                     assert(ex == "***********************-0");
   3646                                     assert(ios.width() == 0);
   3647                                 }
   3648                                 ios.width(25);
   3649                                 internal(ios);
   3650                                 {
   3651                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3652                                     std::string ex(str, iter.base());
   3653                                     assert(ex == "-***********************0");
   3654                                     assert(ios.width() == 0);
   3655                                 }
   3656                             }
   3657                             ios.imbue(lg);
   3658                             {
   3659                                 ios.width(0);
   3660                                 {
   3661                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3662                                     std::string ex(str, iter.base());
   3663                                     assert(ex == "-0");
   3664                                     assert(ios.width() == 0);
   3665                                 }
   3666                                 ios.width(25);
   3667                                 left(ios);
   3668                                 {
   3669                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3670                                     std::string ex(str, iter.base());
   3671                                     assert(ex == "-0***********************");
   3672                                     assert(ios.width() == 0);
   3673                                 }
   3674                                 ios.width(25);
   3675                                 right(ios);
   3676                                 {
   3677                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3678                                     std::string ex(str, iter.base());
   3679                                     assert(ex == "***********************-0");
   3680                                     assert(ios.width() == 0);
   3681                                 }
   3682                                 ios.width(25);
   3683                                 internal(ios);
   3684                                 {
   3685                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3686                                     std::string ex(str, iter.base());
   3687                                     assert(ex == "-***********************0");
   3688                                     assert(ios.width() == 0);
   3689                                 }
   3690                             }
   3691                         }
   3692                         showpoint(ios);
   3693                         {
   3694                             ios.imbue(lc);
   3695                             {
   3696                                 ios.width(0);
   3697                                 {
   3698                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3699                                     std::string ex(str, iter.base());
   3700                                     assert(ex == "-0.");
   3701                                     assert(ios.width() == 0);
   3702                                 }
   3703                                 ios.width(25);
   3704                                 left(ios);
   3705                                 {
   3706                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3707                                     std::string ex(str, iter.base());
   3708                                     assert(ex == "-0.**********************");
   3709                                     assert(ios.width() == 0);
   3710                                 }
   3711                                 ios.width(25);
   3712                                 right(ios);
   3713                                 {
   3714                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3715                                     std::string ex(str, iter.base());
   3716                                     assert(ex == "**********************-0.");
   3717                                     assert(ios.width() == 0);
   3718                                 }
   3719                                 ios.width(25);
   3720                                 internal(ios);
   3721                                 {
   3722                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3723                                     std::string ex(str, iter.base());
   3724                                     assert(ex == "-**********************0.");
   3725                                     assert(ios.width() == 0);
   3726                                 }
   3727                             }
   3728                             ios.imbue(lg);
   3729                             {
   3730                                 ios.width(0);
   3731                                 {
   3732                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3733                                     std::string ex(str, iter.base());
   3734                                     assert(ex == "-0;");
   3735                                     assert(ios.width() == 0);
   3736                                 }
   3737                                 ios.width(25);
   3738                                 left(ios);
   3739                                 {
   3740                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3741                                     std::string ex(str, iter.base());
   3742                                     assert(ex == "-0;**********************");
   3743                                     assert(ios.width() == 0);
   3744                                 }
   3745                                 ios.width(25);
   3746                                 right(ios);
   3747                                 {
   3748                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3749                                     std::string ex(str, iter.base());
   3750                                     assert(ex == "**********************-0;");
   3751                                     assert(ios.width() == 0);
   3752                                 }
   3753                                 ios.width(25);
   3754                                 internal(ios);
   3755                                 {
   3756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3757                                     std::string ex(str, iter.base());
   3758                                     assert(ex == "-**********************0;");
   3759                                     assert(ios.width() == 0);
   3760                                 }
   3761                             }
   3762                         }
   3763                     }
   3764                     showpos(ios);
   3765                     {
   3766                         noshowpoint(ios);
   3767                         {
   3768                             ios.imbue(lc);
   3769                             {
   3770                                 ios.width(0);
   3771                                 {
   3772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3773                                     std::string ex(str, iter.base());
   3774                                     assert(ex == "-0");
   3775                                     assert(ios.width() == 0);
   3776                                 }
   3777                                 ios.width(25);
   3778                                 left(ios);
   3779                                 {
   3780                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3781                                     std::string ex(str, iter.base());
   3782                                     assert(ex == "-0***********************");
   3783                                     assert(ios.width() == 0);
   3784                                 }
   3785                                 ios.width(25);
   3786                                 right(ios);
   3787                                 {
   3788                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3789                                     std::string ex(str, iter.base());
   3790                                     assert(ex == "***********************-0");
   3791                                     assert(ios.width() == 0);
   3792                                 }
   3793                                 ios.width(25);
   3794                                 internal(ios);
   3795                                 {
   3796                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3797                                     std::string ex(str, iter.base());
   3798                                     assert(ex == "-***********************0");
   3799                                     assert(ios.width() == 0);
   3800                                 }
   3801                             }
   3802                             ios.imbue(lg);
   3803                             {
   3804                                 ios.width(0);
   3805                                 {
   3806                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3807                                     std::string ex(str, iter.base());
   3808                                     assert(ex == "-0");
   3809                                     assert(ios.width() == 0);
   3810                                 }
   3811                                 ios.width(25);
   3812                                 left(ios);
   3813                                 {
   3814                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3815                                     std::string ex(str, iter.base());
   3816                                     assert(ex == "-0***********************");
   3817                                     assert(ios.width() == 0);
   3818                                 }
   3819                                 ios.width(25);
   3820                                 right(ios);
   3821                                 {
   3822                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3823                                     std::string ex(str, iter.base());
   3824                                     assert(ex == "***********************-0");
   3825                                     assert(ios.width() == 0);
   3826                                 }
   3827                                 ios.width(25);
   3828                                 internal(ios);
   3829                                 {
   3830                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3831                                     std::string ex(str, iter.base());
   3832                                     assert(ex == "-***********************0");
   3833                                     assert(ios.width() == 0);
   3834                                 }
   3835                             }
   3836                         }
   3837                         showpoint(ios);
   3838                         {
   3839                             ios.imbue(lc);
   3840                             {
   3841                                 ios.width(0);
   3842                                 {
   3843                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3844                                     std::string ex(str, iter.base());
   3845                                     assert(ex == "-0.");
   3846                                     assert(ios.width() == 0);
   3847                                 }
   3848                                 ios.width(25);
   3849                                 left(ios);
   3850                                 {
   3851                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3852                                     std::string ex(str, iter.base());
   3853                                     assert(ex == "-0.**********************");
   3854                                     assert(ios.width() == 0);
   3855                                 }
   3856                                 ios.width(25);
   3857                                 right(ios);
   3858                                 {
   3859                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3860                                     std::string ex(str, iter.base());
   3861                                     assert(ex == "**********************-0.");
   3862                                     assert(ios.width() == 0);
   3863                                 }
   3864                                 ios.width(25);
   3865                                 internal(ios);
   3866                                 {
   3867                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3868                                     std::string ex(str, iter.base());
   3869                                     assert(ex == "-**********************0.");
   3870                                     assert(ios.width() == 0);
   3871                                 }
   3872                             }
   3873                             ios.imbue(lg);
   3874                             {
   3875                                 ios.width(0);
   3876                                 {
   3877                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3878                                     std::string ex(str, iter.base());
   3879                                     assert(ex == "-0;");
   3880                                     assert(ios.width() == 0);
   3881                                 }
   3882                                 ios.width(25);
   3883                                 left(ios);
   3884                                 {
   3885                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3886                                     std::string ex(str, iter.base());
   3887                                     assert(ex == "-0;**********************");
   3888                                     assert(ios.width() == 0);
   3889                                 }
   3890                                 ios.width(25);
   3891                                 right(ios);
   3892                                 {
   3893                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3894                                     std::string ex(str, iter.base());
   3895                                     assert(ex == "**********************-0;");
   3896                                     assert(ios.width() == 0);
   3897                                 }
   3898                                 ios.width(25);
   3899                                 internal(ios);
   3900                                 {
   3901                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3902                                     std::string ex(str, iter.base());
   3903                                     assert(ex == "-**********************0;");
   3904                                     assert(ios.width() == 0);
   3905                                 }
   3906                             }
   3907                         }
   3908                     }
   3909                 }
   3910                 uppercase(ios);
   3911                 {
   3912                     noshowpos(ios);
   3913                     {
   3914                         noshowpoint(ios);
   3915                         {
   3916                             ios.imbue(lc);
   3917                             {
   3918                                 ios.width(0);
   3919                                 {
   3920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3921                                     std::string ex(str, iter.base());
   3922                                     assert(ex == "-0");
   3923                                     assert(ios.width() == 0);
   3924                                 }
   3925                                 ios.width(25);
   3926                                 left(ios);
   3927                                 {
   3928                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3929                                     std::string ex(str, iter.base());
   3930                                     assert(ex == "-0***********************");
   3931                                     assert(ios.width() == 0);
   3932                                 }
   3933                                 ios.width(25);
   3934                                 right(ios);
   3935                                 {
   3936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3937                                     std::string ex(str, iter.base());
   3938                                     assert(ex == "***********************-0");
   3939                                     assert(ios.width() == 0);
   3940                                 }
   3941                                 ios.width(25);
   3942                                 internal(ios);
   3943                                 {
   3944                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3945                                     std::string ex(str, iter.base());
   3946                                     assert(ex == "-***********************0");
   3947                                     assert(ios.width() == 0);
   3948                                 }
   3949                             }
   3950                             ios.imbue(lg);
   3951                             {
   3952                                 ios.width(0);
   3953                                 {
   3954                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3955                                     std::string ex(str, iter.base());
   3956                                     assert(ex == "-0");
   3957                                     assert(ios.width() == 0);
   3958                                 }
   3959                                 ios.width(25);
   3960                                 left(ios);
   3961                                 {
   3962                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3963                                     std::string ex(str, iter.base());
   3964                                     assert(ex == "-0***********************");
   3965                                     assert(ios.width() == 0);
   3966                                 }
   3967                                 ios.width(25);
   3968                                 right(ios);
   3969                                 {
   3970                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3971                                     std::string ex(str, iter.base());
   3972                                     assert(ex == "***********************-0");
   3973                                     assert(ios.width() == 0);
   3974                                 }
   3975                                 ios.width(25);
   3976                                 internal(ios);
   3977                                 {
   3978                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3979                                     std::string ex(str, iter.base());
   3980                                     assert(ex == "-***********************0");
   3981                                     assert(ios.width() == 0);
   3982                                 }
   3983                             }
   3984                         }
   3985                         showpoint(ios);
   3986                         {
   3987                             ios.imbue(lc);
   3988                             {
   3989                                 ios.width(0);
   3990                                 {
   3991                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   3992                                     std::string ex(str, iter.base());
   3993                                     assert(ex == "-0.");
   3994                                     assert(ios.width() == 0);
   3995                                 }
   3996                                 ios.width(25);
   3997                                 left(ios);
   3998                                 {
   3999                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4000                                     std::string ex(str, iter.base());
   4001                                     assert(ex == "-0.**********************");
   4002                                     assert(ios.width() == 0);
   4003                                 }
   4004                                 ios.width(25);
   4005                                 right(ios);
   4006                                 {
   4007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4008                                     std::string ex(str, iter.base());
   4009                                     assert(ex == "**********************-0.");
   4010                                     assert(ios.width() == 0);
   4011                                 }
   4012                                 ios.width(25);
   4013                                 internal(ios);
   4014                                 {
   4015                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4016                                     std::string ex(str, iter.base());
   4017                                     assert(ex == "-**********************0.");
   4018                                     assert(ios.width() == 0);
   4019                                 }
   4020                             }
   4021                             ios.imbue(lg);
   4022                             {
   4023                                 ios.width(0);
   4024                                 {
   4025                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4026                                     std::string ex(str, iter.base());
   4027                                     assert(ex == "-0;");
   4028                                     assert(ios.width() == 0);
   4029                                 }
   4030                                 ios.width(25);
   4031                                 left(ios);
   4032                                 {
   4033                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4034                                     std::string ex(str, iter.base());
   4035                                     assert(ex == "-0;**********************");
   4036                                     assert(ios.width() == 0);
   4037                                 }
   4038                                 ios.width(25);
   4039                                 right(ios);
   4040                                 {
   4041                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4042                                     std::string ex(str, iter.base());
   4043                                     assert(ex == "**********************-0;");
   4044                                     assert(ios.width() == 0);
   4045                                 }
   4046                                 ios.width(25);
   4047                                 internal(ios);
   4048                                 {
   4049                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4050                                     std::string ex(str, iter.base());
   4051                                     assert(ex == "-**********************0;");
   4052                                     assert(ios.width() == 0);
   4053                                 }
   4054                             }
   4055                         }
   4056                     }
   4057                     showpos(ios);
   4058                     {
   4059                         noshowpoint(ios);
   4060                         {
   4061                             ios.imbue(lc);
   4062                             {
   4063                                 ios.width(0);
   4064                                 {
   4065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4066                                     std::string ex(str, iter.base());
   4067                                     assert(ex == "-0");
   4068                                     assert(ios.width() == 0);
   4069                                 }
   4070                                 ios.width(25);
   4071                                 left(ios);
   4072                                 {
   4073                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4074                                     std::string ex(str, iter.base());
   4075                                     assert(ex == "-0***********************");
   4076                                     assert(ios.width() == 0);
   4077                                 }
   4078                                 ios.width(25);
   4079                                 right(ios);
   4080                                 {
   4081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4082                                     std::string ex(str, iter.base());
   4083                                     assert(ex == "***********************-0");
   4084                                     assert(ios.width() == 0);
   4085                                 }
   4086                                 ios.width(25);
   4087                                 internal(ios);
   4088                                 {
   4089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4090                                     std::string ex(str, iter.base());
   4091                                     assert(ex == "-***********************0");
   4092                                     assert(ios.width() == 0);
   4093                                 }
   4094                             }
   4095                             ios.imbue(lg);
   4096                             {
   4097                                 ios.width(0);
   4098                                 {
   4099                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4100                                     std::string ex(str, iter.base());
   4101                                     assert(ex == "-0");
   4102                                     assert(ios.width() == 0);
   4103                                 }
   4104                                 ios.width(25);
   4105                                 left(ios);
   4106                                 {
   4107                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4108                                     std::string ex(str, iter.base());
   4109                                     assert(ex == "-0***********************");
   4110                                     assert(ios.width() == 0);
   4111                                 }
   4112                                 ios.width(25);
   4113                                 right(ios);
   4114                                 {
   4115                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4116                                     std::string ex(str, iter.base());
   4117                                     assert(ex == "***********************-0");
   4118                                     assert(ios.width() == 0);
   4119                                 }
   4120                                 ios.width(25);
   4121                                 internal(ios);
   4122                                 {
   4123                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4124                                     std::string ex(str, iter.base());
   4125                                     assert(ex == "-***********************0");
   4126                                     assert(ios.width() == 0);
   4127                                 }
   4128                             }
   4129                         }
   4130                         showpoint(ios);
   4131                         {
   4132                             ios.imbue(lc);
   4133                             {
   4134                                 ios.width(0);
   4135                                 {
   4136                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4137                                     std::string ex(str, iter.base());
   4138                                     assert(ex == "-0.");
   4139                                     assert(ios.width() == 0);
   4140                                 }
   4141                                 ios.width(25);
   4142                                 left(ios);
   4143                                 {
   4144                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4145                                     std::string ex(str, iter.base());
   4146                                     assert(ex == "-0.**********************");
   4147                                     assert(ios.width() == 0);
   4148                                 }
   4149                                 ios.width(25);
   4150                                 right(ios);
   4151                                 {
   4152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4153                                     std::string ex(str, iter.base());
   4154                                     assert(ex == "**********************-0.");
   4155                                     assert(ios.width() == 0);
   4156                                 }
   4157                                 ios.width(25);
   4158                                 internal(ios);
   4159                                 {
   4160                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4161                                     std::string ex(str, iter.base());
   4162                                     assert(ex == "-**********************0.");
   4163                                     assert(ios.width() == 0);
   4164                                 }
   4165                             }
   4166                             ios.imbue(lg);
   4167                             {
   4168                                 ios.width(0);
   4169                                 {
   4170                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4171                                     std::string ex(str, iter.base());
   4172                                     assert(ex == "-0;");
   4173                                     assert(ios.width() == 0);
   4174                                 }
   4175                                 ios.width(25);
   4176                                 left(ios);
   4177                                 {
   4178                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4179                                     std::string ex(str, iter.base());
   4180                                     assert(ex == "-0;**********************");
   4181                                     assert(ios.width() == 0);
   4182                                 }
   4183                                 ios.width(25);
   4184                                 right(ios);
   4185                                 {
   4186                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4187                                     std::string ex(str, iter.base());
   4188                                     assert(ex == "**********************-0;");
   4189                                     assert(ios.width() == 0);
   4190                                 }
   4191                                 ios.width(25);
   4192                                 internal(ios);
   4193                                 {
   4194                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4195                                     std::string ex(str, iter.base());
   4196                                     assert(ex == "-**********************0;");
   4197                                     assert(ios.width() == 0);
   4198                                 }
   4199                             }
   4200                         }
   4201                     }
   4202                 }
   4203             }
   4204             ios.precision(6);
   4205             {
   4206                 nouppercase(ios);
   4207                 {
   4208                     noshowpos(ios);
   4209                     {
   4210                         noshowpoint(ios);
   4211                         {
   4212                             ios.imbue(lc);
   4213                             {
   4214                                 ios.width(0);
   4215                                 {
   4216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4217                                     std::string ex(str, iter.base());
   4218                                     assert(ex == "-0");
   4219                                     assert(ios.width() == 0);
   4220                                 }
   4221                                 ios.width(25);
   4222                                 left(ios);
   4223                                 {
   4224                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4225                                     std::string ex(str, iter.base());
   4226                                     assert(ex == "-0***********************");
   4227                                     assert(ios.width() == 0);
   4228                                 }
   4229                                 ios.width(25);
   4230                                 right(ios);
   4231                                 {
   4232                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4233                                     std::string ex(str, iter.base());
   4234                                     assert(ex == "***********************-0");
   4235                                     assert(ios.width() == 0);
   4236                                 }
   4237                                 ios.width(25);
   4238                                 internal(ios);
   4239                                 {
   4240                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4241                                     std::string ex(str, iter.base());
   4242                                     assert(ex == "-***********************0");
   4243                                     assert(ios.width() == 0);
   4244                                 }
   4245                             }
   4246                             ios.imbue(lg);
   4247                             {
   4248                                 ios.width(0);
   4249                                 {
   4250                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4251                                     std::string ex(str, iter.base());
   4252                                     assert(ex == "-0");
   4253                                     assert(ios.width() == 0);
   4254                                 }
   4255                                 ios.width(25);
   4256                                 left(ios);
   4257                                 {
   4258                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4259                                     std::string ex(str, iter.base());
   4260                                     assert(ex == "-0***********************");
   4261                                     assert(ios.width() == 0);
   4262                                 }
   4263                                 ios.width(25);
   4264                                 right(ios);
   4265                                 {
   4266                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4267                                     std::string ex(str, iter.base());
   4268                                     assert(ex == "***********************-0");
   4269                                     assert(ios.width() == 0);
   4270                                 }
   4271                                 ios.width(25);
   4272                                 internal(ios);
   4273                                 {
   4274                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4275                                     std::string ex(str, iter.base());
   4276                                     assert(ex == "-***********************0");
   4277                                     assert(ios.width() == 0);
   4278                                 }
   4279                             }
   4280                         }
   4281                         showpoint(ios);
   4282                         {
   4283                             ios.imbue(lc);
   4284                             {
   4285                                 ios.width(0);
   4286                                 {
   4287                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4288                                     std::string ex(str, iter.base());
   4289                                     assert(ex == "-0.00000");
   4290                                     assert(ios.width() == 0);
   4291                                 }
   4292                                 ios.width(25);
   4293                                 left(ios);
   4294                                 {
   4295                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4296                                     std::string ex(str, iter.base());
   4297                                     assert(ex == "-0.00000*****************");
   4298                                     assert(ios.width() == 0);
   4299                                 }
   4300                                 ios.width(25);
   4301                                 right(ios);
   4302                                 {
   4303                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4304                                     std::string ex(str, iter.base());
   4305                                     assert(ex == "*****************-0.00000");
   4306                                     assert(ios.width() == 0);
   4307                                 }
   4308                                 ios.width(25);
   4309                                 internal(ios);
   4310                                 {
   4311                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4312                                     std::string ex(str, iter.base());
   4313                                     assert(ex == "-*****************0.00000");
   4314                                     assert(ios.width() == 0);
   4315                                 }
   4316                             }
   4317                             ios.imbue(lg);
   4318                             {
   4319                                 ios.width(0);
   4320                                 {
   4321                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4322                                     std::string ex(str, iter.base());
   4323                                     assert(ex == "-0;00000");
   4324                                     assert(ios.width() == 0);
   4325                                 }
   4326                                 ios.width(25);
   4327                                 left(ios);
   4328                                 {
   4329                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4330                                     std::string ex(str, iter.base());
   4331                                     assert(ex == "-0;00000*****************");
   4332                                     assert(ios.width() == 0);
   4333                                 }
   4334                                 ios.width(25);
   4335                                 right(ios);
   4336                                 {
   4337                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4338                                     std::string ex(str, iter.base());
   4339                                     assert(ex == "*****************-0;00000");
   4340                                     assert(ios.width() == 0);
   4341                                 }
   4342                                 ios.width(25);
   4343                                 internal(ios);
   4344                                 {
   4345                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4346                                     std::string ex(str, iter.base());
   4347                                     assert(ex == "-*****************0;00000");
   4348                                     assert(ios.width() == 0);
   4349                                 }
   4350                             }
   4351                         }
   4352                     }
   4353                     showpos(ios);
   4354                     {
   4355                         noshowpoint(ios);
   4356                         {
   4357                             ios.imbue(lc);
   4358                             {
   4359                                 ios.width(0);
   4360                                 {
   4361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4362                                     std::string ex(str, iter.base());
   4363                                     assert(ex == "-0");
   4364                                     assert(ios.width() == 0);
   4365                                 }
   4366                                 ios.width(25);
   4367                                 left(ios);
   4368                                 {
   4369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4370                                     std::string ex(str, iter.base());
   4371                                     assert(ex == "-0***********************");
   4372                                     assert(ios.width() == 0);
   4373                                 }
   4374                                 ios.width(25);
   4375                                 right(ios);
   4376                                 {
   4377                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4378                                     std::string ex(str, iter.base());
   4379                                     assert(ex == "***********************-0");
   4380                                     assert(ios.width() == 0);
   4381                                 }
   4382                                 ios.width(25);
   4383                                 internal(ios);
   4384                                 {
   4385                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4386                                     std::string ex(str, iter.base());
   4387                                     assert(ex == "-***********************0");
   4388                                     assert(ios.width() == 0);
   4389                                 }
   4390                             }
   4391                             ios.imbue(lg);
   4392                             {
   4393                                 ios.width(0);
   4394                                 {
   4395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4396                                     std::string ex(str, iter.base());
   4397                                     assert(ex == "-0");
   4398                                     assert(ios.width() == 0);
   4399                                 }
   4400                                 ios.width(25);
   4401                                 left(ios);
   4402                                 {
   4403                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4404                                     std::string ex(str, iter.base());
   4405                                     assert(ex == "-0***********************");
   4406                                     assert(ios.width() == 0);
   4407                                 }
   4408                                 ios.width(25);
   4409                                 right(ios);
   4410                                 {
   4411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4412                                     std::string ex(str, iter.base());
   4413                                     assert(ex == "***********************-0");
   4414                                     assert(ios.width() == 0);
   4415                                 }
   4416                                 ios.width(25);
   4417                                 internal(ios);
   4418                                 {
   4419                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4420                                     std::string ex(str, iter.base());
   4421                                     assert(ex == "-***********************0");
   4422                                     assert(ios.width() == 0);
   4423                                 }
   4424                             }
   4425                         }
   4426                         showpoint(ios);
   4427                         {
   4428                             ios.imbue(lc);
   4429                             {
   4430                                 ios.width(0);
   4431                                 {
   4432                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4433                                     std::string ex(str, iter.base());
   4434                                     assert(ex == "-0.00000");
   4435                                     assert(ios.width() == 0);
   4436                                 }
   4437                                 ios.width(25);
   4438                                 left(ios);
   4439                                 {
   4440                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4441                                     std::string ex(str, iter.base());
   4442                                     assert(ex == "-0.00000*****************");
   4443                                     assert(ios.width() == 0);
   4444                                 }
   4445                                 ios.width(25);
   4446                                 right(ios);
   4447                                 {
   4448                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4449                                     std::string ex(str, iter.base());
   4450                                     assert(ex == "*****************-0.00000");
   4451                                     assert(ios.width() == 0);
   4452                                 }
   4453                                 ios.width(25);
   4454                                 internal(ios);
   4455                                 {
   4456                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4457                                     std::string ex(str, iter.base());
   4458                                     assert(ex == "-*****************0.00000");
   4459                                     assert(ios.width() == 0);
   4460                                 }
   4461                             }
   4462                             ios.imbue(lg);
   4463                             {
   4464                                 ios.width(0);
   4465                                 {
   4466                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4467                                     std::string ex(str, iter.base());
   4468                                     assert(ex == "-0;00000");
   4469                                     assert(ios.width() == 0);
   4470                                 }
   4471                                 ios.width(25);
   4472                                 left(ios);
   4473                                 {
   4474                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4475                                     std::string ex(str, iter.base());
   4476                                     assert(ex == "-0;00000*****************");
   4477                                     assert(ios.width() == 0);
   4478                                 }
   4479                                 ios.width(25);
   4480                                 right(ios);
   4481                                 {
   4482                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4483                                     std::string ex(str, iter.base());
   4484                                     assert(ex == "*****************-0;00000");
   4485                                     assert(ios.width() == 0);
   4486                                 }
   4487                                 ios.width(25);
   4488                                 internal(ios);
   4489                                 {
   4490                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4491                                     std::string ex(str, iter.base());
   4492                                     assert(ex == "-*****************0;00000");
   4493                                     assert(ios.width() == 0);
   4494                                 }
   4495                             }
   4496                         }
   4497                     }
   4498                 }
   4499                 uppercase(ios);
   4500                 {
   4501                     noshowpos(ios);
   4502                     {
   4503                         noshowpoint(ios);
   4504                         {
   4505                             ios.imbue(lc);
   4506                             {
   4507                                 ios.width(0);
   4508                                 {
   4509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4510                                     std::string ex(str, iter.base());
   4511                                     assert(ex == "-0");
   4512                                     assert(ios.width() == 0);
   4513                                 }
   4514                                 ios.width(25);
   4515                                 left(ios);
   4516                                 {
   4517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4518                                     std::string ex(str, iter.base());
   4519                                     assert(ex == "-0***********************");
   4520                                     assert(ios.width() == 0);
   4521                                 }
   4522                                 ios.width(25);
   4523                                 right(ios);
   4524                                 {
   4525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4526                                     std::string ex(str, iter.base());
   4527                                     assert(ex == "***********************-0");
   4528                                     assert(ios.width() == 0);
   4529                                 }
   4530                                 ios.width(25);
   4531                                 internal(ios);
   4532                                 {
   4533                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4534                                     std::string ex(str, iter.base());
   4535                                     assert(ex == "-***********************0");
   4536                                     assert(ios.width() == 0);
   4537                                 }
   4538                             }
   4539                             ios.imbue(lg);
   4540                             {
   4541                                 ios.width(0);
   4542                                 {
   4543                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4544                                     std::string ex(str, iter.base());
   4545                                     assert(ex == "-0");
   4546                                     assert(ios.width() == 0);
   4547                                 }
   4548                                 ios.width(25);
   4549                                 left(ios);
   4550                                 {
   4551                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4552                                     std::string ex(str, iter.base());
   4553                                     assert(ex == "-0***********************");
   4554                                     assert(ios.width() == 0);
   4555                                 }
   4556                                 ios.width(25);
   4557                                 right(ios);
   4558                                 {
   4559                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4560                                     std::string ex(str, iter.base());
   4561                                     assert(ex == "***********************-0");
   4562                                     assert(ios.width() == 0);
   4563                                 }
   4564                                 ios.width(25);
   4565                                 internal(ios);
   4566                                 {
   4567                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4568                                     std::string ex(str, iter.base());
   4569                                     assert(ex == "-***********************0");
   4570                                     assert(ios.width() == 0);
   4571                                 }
   4572                             }
   4573                         }
   4574                         showpoint(ios);
   4575                         {
   4576                             ios.imbue(lc);
   4577                             {
   4578                                 ios.width(0);
   4579                                 {
   4580                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4581                                     std::string ex(str, iter.base());
   4582                                     assert(ex == "-0.00000");
   4583                                     assert(ios.width() == 0);
   4584                                 }
   4585                                 ios.width(25);
   4586                                 left(ios);
   4587                                 {
   4588                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4589                                     std::string ex(str, iter.base());
   4590                                     assert(ex == "-0.00000*****************");
   4591                                     assert(ios.width() == 0);
   4592                                 }
   4593                                 ios.width(25);
   4594                                 right(ios);
   4595                                 {
   4596                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4597                                     std::string ex(str, iter.base());
   4598                                     assert(ex == "*****************-0.00000");
   4599                                     assert(ios.width() == 0);
   4600                                 }
   4601                                 ios.width(25);
   4602                                 internal(ios);
   4603                                 {
   4604                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4605                                     std::string ex(str, iter.base());
   4606                                     assert(ex == "-*****************0.00000");
   4607                                     assert(ios.width() == 0);
   4608                                 }
   4609                             }
   4610                             ios.imbue(lg);
   4611                             {
   4612                                 ios.width(0);
   4613                                 {
   4614                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4615                                     std::string ex(str, iter.base());
   4616                                     assert(ex == "-0;00000");
   4617                                     assert(ios.width() == 0);
   4618                                 }
   4619                                 ios.width(25);
   4620                                 left(ios);
   4621                                 {
   4622                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4623                                     std::string ex(str, iter.base());
   4624                                     assert(ex == "-0;00000*****************");
   4625                                     assert(ios.width() == 0);
   4626                                 }
   4627                                 ios.width(25);
   4628                                 right(ios);
   4629                                 {
   4630                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4631                                     std::string ex(str, iter.base());
   4632                                     assert(ex == "*****************-0;00000");
   4633                                     assert(ios.width() == 0);
   4634                                 }
   4635                                 ios.width(25);
   4636                                 internal(ios);
   4637                                 {
   4638                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4639                                     std::string ex(str, iter.base());
   4640                                     assert(ex == "-*****************0;00000");
   4641                                     assert(ios.width() == 0);
   4642                                 }
   4643                             }
   4644                         }
   4645                     }
   4646                     showpos(ios);
   4647                     {
   4648                         noshowpoint(ios);
   4649                         {
   4650                             ios.imbue(lc);
   4651                             {
   4652                                 ios.width(0);
   4653                                 {
   4654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4655                                     std::string ex(str, iter.base());
   4656                                     assert(ex == "-0");
   4657                                     assert(ios.width() == 0);
   4658                                 }
   4659                                 ios.width(25);
   4660                                 left(ios);
   4661                                 {
   4662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4663                                     std::string ex(str, iter.base());
   4664                                     assert(ex == "-0***********************");
   4665                                     assert(ios.width() == 0);
   4666                                 }
   4667                                 ios.width(25);
   4668                                 right(ios);
   4669                                 {
   4670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4671                                     std::string ex(str, iter.base());
   4672                                     assert(ex == "***********************-0");
   4673                                     assert(ios.width() == 0);
   4674                                 }
   4675                                 ios.width(25);
   4676                                 internal(ios);
   4677                                 {
   4678                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4679                                     std::string ex(str, iter.base());
   4680                                     assert(ex == "-***********************0");
   4681                                     assert(ios.width() == 0);
   4682                                 }
   4683                             }
   4684                             ios.imbue(lg);
   4685                             {
   4686                                 ios.width(0);
   4687                                 {
   4688                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4689                                     std::string ex(str, iter.base());
   4690                                     assert(ex == "-0");
   4691                                     assert(ios.width() == 0);
   4692                                 }
   4693                                 ios.width(25);
   4694                                 left(ios);
   4695                                 {
   4696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4697                                     std::string ex(str, iter.base());
   4698                                     assert(ex == "-0***********************");
   4699                                     assert(ios.width() == 0);
   4700                                 }
   4701                                 ios.width(25);
   4702                                 right(ios);
   4703                                 {
   4704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4705                                     std::string ex(str, iter.base());
   4706                                     assert(ex == "***********************-0");
   4707                                     assert(ios.width() == 0);
   4708                                 }
   4709                                 ios.width(25);
   4710                                 internal(ios);
   4711                                 {
   4712                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4713                                     std::string ex(str, iter.base());
   4714                                     assert(ex == "-***********************0");
   4715                                     assert(ios.width() == 0);
   4716                                 }
   4717                             }
   4718                         }
   4719                         showpoint(ios);
   4720                         {
   4721                             ios.imbue(lc);
   4722                             {
   4723                                 ios.width(0);
   4724                                 {
   4725                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4726                                     std::string ex(str, iter.base());
   4727                                     assert(ex == "-0.00000");
   4728                                     assert(ios.width() == 0);
   4729                                 }
   4730                                 ios.width(25);
   4731                                 left(ios);
   4732                                 {
   4733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4734                                     std::string ex(str, iter.base());
   4735                                     assert(ex == "-0.00000*****************");
   4736                                     assert(ios.width() == 0);
   4737                                 }
   4738                                 ios.width(25);
   4739                                 right(ios);
   4740                                 {
   4741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4742                                     std::string ex(str, iter.base());
   4743                                     assert(ex == "*****************-0.00000");
   4744                                     assert(ios.width() == 0);
   4745                                 }
   4746                                 ios.width(25);
   4747                                 internal(ios);
   4748                                 {
   4749                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4750                                     std::string ex(str, iter.base());
   4751                                     assert(ex == "-*****************0.00000");
   4752                                     assert(ios.width() == 0);
   4753                                 }
   4754                             }
   4755                             ios.imbue(lg);
   4756                             {
   4757                                 ios.width(0);
   4758                                 {
   4759                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4760                                     std::string ex(str, iter.base());
   4761                                     assert(ex == "-0;00000");
   4762                                     assert(ios.width() == 0);
   4763                                 }
   4764                                 ios.width(25);
   4765                                 left(ios);
   4766                                 {
   4767                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4768                                     std::string ex(str, iter.base());
   4769                                     assert(ex == "-0;00000*****************");
   4770                                     assert(ios.width() == 0);
   4771                                 }
   4772                                 ios.width(25);
   4773                                 right(ios);
   4774                                 {
   4775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4776                                     std::string ex(str, iter.base());
   4777                                     assert(ex == "*****************-0;00000");
   4778                                     assert(ios.width() == 0);
   4779                                 }
   4780                                 ios.width(25);
   4781                                 internal(ios);
   4782                                 {
   4783                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4784                                     std::string ex(str, iter.base());
   4785                                     assert(ex == "-*****************0;00000");
   4786                                     assert(ios.width() == 0);
   4787                                 }
   4788                             }
   4789                         }
   4790                     }
   4791                 }
   4792             }
   4793             ios.precision(16);
   4794             {
   4795                 nouppercase(ios);
   4796                 {
   4797                     noshowpos(ios);
   4798                     {
   4799                         noshowpoint(ios);
   4800                         {
   4801                             ios.imbue(lc);
   4802                             {
   4803                                 ios.width(0);
   4804                                 {
   4805                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4806                                     std::string ex(str, iter.base());
   4807                                     assert(ex == "-0");
   4808                                     assert(ios.width() == 0);
   4809                                 }
   4810                                 ios.width(25);
   4811                                 left(ios);
   4812                                 {
   4813                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4814                                     std::string ex(str, iter.base());
   4815                                     assert(ex == "-0***********************");
   4816                                     assert(ios.width() == 0);
   4817                                 }
   4818                                 ios.width(25);
   4819                                 right(ios);
   4820                                 {
   4821                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4822                                     std::string ex(str, iter.base());
   4823                                     assert(ex == "***********************-0");
   4824                                     assert(ios.width() == 0);
   4825                                 }
   4826                                 ios.width(25);
   4827                                 internal(ios);
   4828                                 {
   4829                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4830                                     std::string ex(str, iter.base());
   4831                                     assert(ex == "-***********************0");
   4832                                     assert(ios.width() == 0);
   4833                                 }
   4834                             }
   4835                             ios.imbue(lg);
   4836                             {
   4837                                 ios.width(0);
   4838                                 {
   4839                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4840                                     std::string ex(str, iter.base());
   4841                                     assert(ex == "-0");
   4842                                     assert(ios.width() == 0);
   4843                                 }
   4844                                 ios.width(25);
   4845                                 left(ios);
   4846                                 {
   4847                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4848                                     std::string ex(str, iter.base());
   4849                                     assert(ex == "-0***********************");
   4850                                     assert(ios.width() == 0);
   4851                                 }
   4852                                 ios.width(25);
   4853                                 right(ios);
   4854                                 {
   4855                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4856                                     std::string ex(str, iter.base());
   4857                                     assert(ex == "***********************-0");
   4858                                     assert(ios.width() == 0);
   4859                                 }
   4860                                 ios.width(25);
   4861                                 internal(ios);
   4862                                 {
   4863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4864                                     std::string ex(str, iter.base());
   4865                                     assert(ex == "-***********************0");
   4866                                     assert(ios.width() == 0);
   4867                                 }
   4868                             }
   4869                         }
   4870                         showpoint(ios);
   4871                         {
   4872                             ios.imbue(lc);
   4873                             {
   4874                                 ios.width(0);
   4875                                 {
   4876                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4877                                     std::string ex(str, iter.base());
   4878                                     assert(ex == "-0.000000000000000");
   4879                                     assert(ios.width() == 0);
   4880                                 }
   4881                                 ios.width(25);
   4882                                 left(ios);
   4883                                 {
   4884                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4885                                     std::string ex(str, iter.base());
   4886                                     assert(ex == "-0.000000000000000*******");
   4887                                     assert(ios.width() == 0);
   4888                                 }
   4889                                 ios.width(25);
   4890                                 right(ios);
   4891                                 {
   4892                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4893                                     std::string ex(str, iter.base());
   4894                                     assert(ex == "*******-0.000000000000000");
   4895                                     assert(ios.width() == 0);
   4896                                 }
   4897                                 ios.width(25);
   4898                                 internal(ios);
   4899                                 {
   4900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4901                                     std::string ex(str, iter.base());
   4902                                     assert(ex == "-*******0.000000000000000");
   4903                                     assert(ios.width() == 0);
   4904                                 }
   4905                             }
   4906                             ios.imbue(lg);
   4907                             {
   4908                                 ios.width(0);
   4909                                 {
   4910                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4911                                     std::string ex(str, iter.base());
   4912                                     assert(ex == "-0;000000000000000");
   4913                                     assert(ios.width() == 0);
   4914                                 }
   4915                                 ios.width(25);
   4916                                 left(ios);
   4917                                 {
   4918                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4919                                     std::string ex(str, iter.base());
   4920                                     assert(ex == "-0;000000000000000*******");
   4921                                     assert(ios.width() == 0);
   4922                                 }
   4923                                 ios.width(25);
   4924                                 right(ios);
   4925                                 {
   4926                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4927                                     std::string ex(str, iter.base());
   4928                                     assert(ex == "*******-0;000000000000000");
   4929                                     assert(ios.width() == 0);
   4930                                 }
   4931                                 ios.width(25);
   4932                                 internal(ios);
   4933                                 {
   4934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4935                                     std::string ex(str, iter.base());
   4936                                     assert(ex == "-*******0;000000000000000");
   4937                                     assert(ios.width() == 0);
   4938                                 }
   4939                             }
   4940                         }
   4941                     }
   4942                     showpos(ios);
   4943                     {
   4944                         noshowpoint(ios);
   4945                         {
   4946                             ios.imbue(lc);
   4947                             {
   4948                                 ios.width(0);
   4949                                 {
   4950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4951                                     std::string ex(str, iter.base());
   4952                                     assert(ex == "-0");
   4953                                     assert(ios.width() == 0);
   4954                                 }
   4955                                 ios.width(25);
   4956                                 left(ios);
   4957                                 {
   4958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4959                                     std::string ex(str, iter.base());
   4960                                     assert(ex == "-0***********************");
   4961                                     assert(ios.width() == 0);
   4962                                 }
   4963                                 ios.width(25);
   4964                                 right(ios);
   4965                                 {
   4966                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4967                                     std::string ex(str, iter.base());
   4968                                     assert(ex == "***********************-0");
   4969                                     assert(ios.width() == 0);
   4970                                 }
   4971                                 ios.width(25);
   4972                                 internal(ios);
   4973                                 {
   4974                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4975                                     std::string ex(str, iter.base());
   4976                                     assert(ex == "-***********************0");
   4977                                     assert(ios.width() == 0);
   4978                                 }
   4979                             }
   4980                             ios.imbue(lg);
   4981                             {
   4982                                 ios.width(0);
   4983                                 {
   4984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4985                                     std::string ex(str, iter.base());
   4986                                     assert(ex == "-0");
   4987                                     assert(ios.width() == 0);
   4988                                 }
   4989                                 ios.width(25);
   4990                                 left(ios);
   4991                                 {
   4992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   4993                                     std::string ex(str, iter.base());
   4994                                     assert(ex == "-0***********************");
   4995                                     assert(ios.width() == 0);
   4996                                 }
   4997                                 ios.width(25);
   4998                                 right(ios);
   4999                                 {
   5000                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5001                                     std::string ex(str, iter.base());
   5002                                     assert(ex == "***********************-0");
   5003                                     assert(ios.width() == 0);
   5004                                 }
   5005                                 ios.width(25);
   5006                                 internal(ios);
   5007                                 {
   5008                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5009                                     std::string ex(str, iter.base());
   5010                                     assert(ex == "-***********************0");
   5011                                     assert(ios.width() == 0);
   5012                                 }
   5013                             }
   5014                         }
   5015                         showpoint(ios);
   5016                         {
   5017                             ios.imbue(lc);
   5018                             {
   5019                                 ios.width(0);
   5020                                 {
   5021                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5022                                     std::string ex(str, iter.base());
   5023                                     assert(ex == "-0.000000000000000");
   5024                                     assert(ios.width() == 0);
   5025                                 }
   5026                                 ios.width(25);
   5027                                 left(ios);
   5028                                 {
   5029                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5030                                     std::string ex(str, iter.base());
   5031                                     assert(ex == "-0.000000000000000*******");
   5032                                     assert(ios.width() == 0);
   5033                                 }
   5034                                 ios.width(25);
   5035                                 right(ios);
   5036                                 {
   5037                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5038                                     std::string ex(str, iter.base());
   5039                                     assert(ex == "*******-0.000000000000000");
   5040                                     assert(ios.width() == 0);
   5041                                 }
   5042                                 ios.width(25);
   5043                                 internal(ios);
   5044                                 {
   5045                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5046                                     std::string ex(str, iter.base());
   5047                                     assert(ex == "-*******0.000000000000000");
   5048                                     assert(ios.width() == 0);
   5049                                 }
   5050                             }
   5051                             ios.imbue(lg);
   5052                             {
   5053                                 ios.width(0);
   5054                                 {
   5055                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5056                                     std::string ex(str, iter.base());
   5057                                     assert(ex == "-0;000000000000000");
   5058                                     assert(ios.width() == 0);
   5059                                 }
   5060                                 ios.width(25);
   5061                                 left(ios);
   5062                                 {
   5063                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5064                                     std::string ex(str, iter.base());
   5065                                     assert(ex == "-0;000000000000000*******");
   5066                                     assert(ios.width() == 0);
   5067                                 }
   5068                                 ios.width(25);
   5069                                 right(ios);
   5070                                 {
   5071                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5072                                     std::string ex(str, iter.base());
   5073                                     assert(ex == "*******-0;000000000000000");
   5074                                     assert(ios.width() == 0);
   5075                                 }
   5076                                 ios.width(25);
   5077                                 internal(ios);
   5078                                 {
   5079                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5080                                     std::string ex(str, iter.base());
   5081                                     assert(ex == "-*******0;000000000000000");
   5082                                     assert(ios.width() == 0);
   5083                                 }
   5084                             }
   5085                         }
   5086                     }
   5087                 }
   5088                 uppercase(ios);
   5089                 {
   5090                     noshowpos(ios);
   5091                     {
   5092                         noshowpoint(ios);
   5093                         {
   5094                             ios.imbue(lc);
   5095                             {
   5096                                 ios.width(0);
   5097                                 {
   5098                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5099                                     std::string ex(str, iter.base());
   5100                                     assert(ex == "-0");
   5101                                     assert(ios.width() == 0);
   5102                                 }
   5103                                 ios.width(25);
   5104                                 left(ios);
   5105                                 {
   5106                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5107                                     std::string ex(str, iter.base());
   5108                                     assert(ex == "-0***********************");
   5109                                     assert(ios.width() == 0);
   5110                                 }
   5111                                 ios.width(25);
   5112                                 right(ios);
   5113                                 {
   5114                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5115                                     std::string ex(str, iter.base());
   5116                                     assert(ex == "***********************-0");
   5117                                     assert(ios.width() == 0);
   5118                                 }
   5119                                 ios.width(25);
   5120                                 internal(ios);
   5121                                 {
   5122                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5123                                     std::string ex(str, iter.base());
   5124                                     assert(ex == "-***********************0");
   5125                                     assert(ios.width() == 0);
   5126                                 }
   5127                             }
   5128                             ios.imbue(lg);
   5129                             {
   5130                                 ios.width(0);
   5131                                 {
   5132                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5133                                     std::string ex(str, iter.base());
   5134                                     assert(ex == "-0");
   5135                                     assert(ios.width() == 0);
   5136                                 }
   5137                                 ios.width(25);
   5138                                 left(ios);
   5139                                 {
   5140                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5141                                     std::string ex(str, iter.base());
   5142                                     assert(ex == "-0***********************");
   5143                                     assert(ios.width() == 0);
   5144                                 }
   5145                                 ios.width(25);
   5146                                 right(ios);
   5147                                 {
   5148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5149                                     std::string ex(str, iter.base());
   5150                                     assert(ex == "***********************-0");
   5151                                     assert(ios.width() == 0);
   5152                                 }
   5153                                 ios.width(25);
   5154                                 internal(ios);
   5155                                 {
   5156                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5157                                     std::string ex(str, iter.base());
   5158                                     assert(ex == "-***********************0");
   5159                                     assert(ios.width() == 0);
   5160                                 }
   5161                             }
   5162                         }
   5163                         showpoint(ios);
   5164                         {
   5165                             ios.imbue(lc);
   5166                             {
   5167                                 ios.width(0);
   5168                                 {
   5169                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5170                                     std::string ex(str, iter.base());
   5171                                     assert(ex == "-0.000000000000000");
   5172                                     assert(ios.width() == 0);
   5173                                 }
   5174                                 ios.width(25);
   5175                                 left(ios);
   5176                                 {
   5177                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5178                                     std::string ex(str, iter.base());
   5179                                     assert(ex == "-0.000000000000000*******");
   5180                                     assert(ios.width() == 0);
   5181                                 }
   5182                                 ios.width(25);
   5183                                 right(ios);
   5184                                 {
   5185                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5186                                     std::string ex(str, iter.base());
   5187                                     assert(ex == "*******-0.000000000000000");
   5188                                     assert(ios.width() == 0);
   5189                                 }
   5190                                 ios.width(25);
   5191                                 internal(ios);
   5192                                 {
   5193                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5194                                     std::string ex(str, iter.base());
   5195                                     assert(ex == "-*******0.000000000000000");
   5196                                     assert(ios.width() == 0);
   5197                                 }
   5198                             }
   5199                             ios.imbue(lg);
   5200                             {
   5201                                 ios.width(0);
   5202                                 {
   5203                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5204                                     std::string ex(str, iter.base());
   5205                                     assert(ex == "-0;000000000000000");
   5206                                     assert(ios.width() == 0);
   5207                                 }
   5208                                 ios.width(25);
   5209                                 left(ios);
   5210                                 {
   5211                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5212                                     std::string ex(str, iter.base());
   5213                                     assert(ex == "-0;000000000000000*******");
   5214                                     assert(ios.width() == 0);
   5215                                 }
   5216                                 ios.width(25);
   5217                                 right(ios);
   5218                                 {
   5219                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5220                                     std::string ex(str, iter.base());
   5221                                     assert(ex == "*******-0;000000000000000");
   5222                                     assert(ios.width() == 0);
   5223                                 }
   5224                                 ios.width(25);
   5225                                 internal(ios);
   5226                                 {
   5227                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5228                                     std::string ex(str, iter.base());
   5229                                     assert(ex == "-*******0;000000000000000");
   5230                                     assert(ios.width() == 0);
   5231                                 }
   5232                             }
   5233                         }
   5234                     }
   5235                     showpos(ios);
   5236                     {
   5237                         noshowpoint(ios);
   5238                         {
   5239                             ios.imbue(lc);
   5240                             {
   5241                                 ios.width(0);
   5242                                 {
   5243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5244                                     std::string ex(str, iter.base());
   5245                                     assert(ex == "-0");
   5246                                     assert(ios.width() == 0);
   5247                                 }
   5248                                 ios.width(25);
   5249                                 left(ios);
   5250                                 {
   5251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5252                                     std::string ex(str, iter.base());
   5253                                     assert(ex == "-0***********************");
   5254                                     assert(ios.width() == 0);
   5255                                 }
   5256                                 ios.width(25);
   5257                                 right(ios);
   5258                                 {
   5259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5260                                     std::string ex(str, iter.base());
   5261                                     assert(ex == "***********************-0");
   5262                                     assert(ios.width() == 0);
   5263                                 }
   5264                                 ios.width(25);
   5265                                 internal(ios);
   5266                                 {
   5267                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5268                                     std::string ex(str, iter.base());
   5269                                     assert(ex == "-***********************0");
   5270                                     assert(ios.width() == 0);
   5271                                 }
   5272                             }
   5273                             ios.imbue(lg);
   5274                             {
   5275                                 ios.width(0);
   5276                                 {
   5277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5278                                     std::string ex(str, iter.base());
   5279                                     assert(ex == "-0");
   5280                                     assert(ios.width() == 0);
   5281                                 }
   5282                                 ios.width(25);
   5283                                 left(ios);
   5284                                 {
   5285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5286                                     std::string ex(str, iter.base());
   5287                                     assert(ex == "-0***********************");
   5288                                     assert(ios.width() == 0);
   5289                                 }
   5290                                 ios.width(25);
   5291                                 right(ios);
   5292                                 {
   5293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5294                                     std::string ex(str, iter.base());
   5295                                     assert(ex == "***********************-0");
   5296                                     assert(ios.width() == 0);
   5297                                 }
   5298                                 ios.width(25);
   5299                                 internal(ios);
   5300                                 {
   5301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5302                                     std::string ex(str, iter.base());
   5303                                     assert(ex == "-***********************0");
   5304                                     assert(ios.width() == 0);
   5305                                 }
   5306                             }
   5307                         }
   5308                         showpoint(ios);
   5309                         {
   5310                             ios.imbue(lc);
   5311                             {
   5312                                 ios.width(0);
   5313                                 {
   5314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5315                                     std::string ex(str, iter.base());
   5316                                     assert(ex == "-0.000000000000000");
   5317                                     assert(ios.width() == 0);
   5318                                 }
   5319                                 ios.width(25);
   5320                                 left(ios);
   5321                                 {
   5322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5323                                     std::string ex(str, iter.base());
   5324                                     assert(ex == "-0.000000000000000*******");
   5325                                     assert(ios.width() == 0);
   5326                                 }
   5327                                 ios.width(25);
   5328                                 right(ios);
   5329                                 {
   5330                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5331                                     std::string ex(str, iter.base());
   5332                                     assert(ex == "*******-0.000000000000000");
   5333                                     assert(ios.width() == 0);
   5334                                 }
   5335                                 ios.width(25);
   5336                                 internal(ios);
   5337                                 {
   5338                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5339                                     std::string ex(str, iter.base());
   5340                                     assert(ex == "-*******0.000000000000000");
   5341                                     assert(ios.width() == 0);
   5342                                 }
   5343                             }
   5344                             ios.imbue(lg);
   5345                             {
   5346                                 ios.width(0);
   5347                                 {
   5348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5349                                     std::string ex(str, iter.base());
   5350                                     assert(ex == "-0;000000000000000");
   5351                                     assert(ios.width() == 0);
   5352                                 }
   5353                                 ios.width(25);
   5354                                 left(ios);
   5355                                 {
   5356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5357                                     std::string ex(str, iter.base());
   5358                                     assert(ex == "-0;000000000000000*******");
   5359                                     assert(ios.width() == 0);
   5360                                 }
   5361                                 ios.width(25);
   5362                                 right(ios);
   5363                                 {
   5364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5365                                     std::string ex(str, iter.base());
   5366                                     assert(ex == "*******-0;000000000000000");
   5367                                     assert(ios.width() == 0);
   5368                                 }
   5369                                 ios.width(25);
   5370                                 internal(ios);
   5371                                 {
   5372                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5373                                     std::string ex(str, iter.base());
   5374                                     assert(ex == "-*******0;000000000000000");
   5375                                     assert(ios.width() == 0);
   5376                                 }
   5377                             }
   5378                         }
   5379                     }
   5380                 }
   5381             }
   5382             ios.precision(60);
   5383             {
   5384                 nouppercase(ios);
   5385                 {
   5386                     noshowpos(ios);
   5387                     {
   5388                         noshowpoint(ios);
   5389                         {
   5390                             ios.imbue(lc);
   5391                             {
   5392                                 ios.width(0);
   5393                                 {
   5394                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5395                                     std::string ex(str, iter.base());
   5396                                     assert(ex == "-0");
   5397                                     assert(ios.width() == 0);
   5398                                 }
   5399                                 ios.width(25);
   5400                                 left(ios);
   5401                                 {
   5402                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5403                                     std::string ex(str, iter.base());
   5404                                     assert(ex == "-0***********************");
   5405                                     assert(ios.width() == 0);
   5406                                 }
   5407                                 ios.width(25);
   5408                                 right(ios);
   5409                                 {
   5410                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5411                                     std::string ex(str, iter.base());
   5412                                     assert(ex == "***********************-0");
   5413                                     assert(ios.width() == 0);
   5414                                 }
   5415                                 ios.width(25);
   5416                                 internal(ios);
   5417                                 {
   5418                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5419                                     std::string ex(str, iter.base());
   5420                                     assert(ex == "-***********************0");
   5421                                     assert(ios.width() == 0);
   5422                                 }
   5423                             }
   5424                             ios.imbue(lg);
   5425                             {
   5426                                 ios.width(0);
   5427                                 {
   5428                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5429                                     std::string ex(str, iter.base());
   5430                                     assert(ex == "-0");
   5431                                     assert(ios.width() == 0);
   5432                                 }
   5433                                 ios.width(25);
   5434                                 left(ios);
   5435                                 {
   5436                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5437                                     std::string ex(str, iter.base());
   5438                                     assert(ex == "-0***********************");
   5439                                     assert(ios.width() == 0);
   5440                                 }
   5441                                 ios.width(25);
   5442                                 right(ios);
   5443                                 {
   5444                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5445                                     std::string ex(str, iter.base());
   5446                                     assert(ex == "***********************-0");
   5447                                     assert(ios.width() == 0);
   5448                                 }
   5449                                 ios.width(25);
   5450                                 internal(ios);
   5451                                 {
   5452                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5453                                     std::string ex(str, iter.base());
   5454                                     assert(ex == "-***********************0");
   5455                                     assert(ios.width() == 0);
   5456                                 }
   5457                             }
   5458                         }
   5459                         showpoint(ios);
   5460                         {
   5461                             ios.imbue(lc);
   5462                             {
   5463                                 ios.width(0);
   5464                                 {
   5465                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5466                                     std::string ex(str, iter.base());
   5467                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5468                                     assert(ios.width() == 0);
   5469                                 }
   5470                                 ios.width(25);
   5471                                 left(ios);
   5472                                 {
   5473                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5474                                     std::string ex(str, iter.base());
   5475                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5476                                     assert(ios.width() == 0);
   5477                                 }
   5478                                 ios.width(25);
   5479                                 right(ios);
   5480                                 {
   5481                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5482                                     std::string ex(str, iter.base());
   5483                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5484                                     assert(ios.width() == 0);
   5485                                 }
   5486                                 ios.width(25);
   5487                                 internal(ios);
   5488                                 {
   5489                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5490                                     std::string ex(str, iter.base());
   5491                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5492                                     assert(ios.width() == 0);
   5493                                 }
   5494                             }
   5495                             ios.imbue(lg);
   5496                             {
   5497                                 ios.width(0);
   5498                                 {
   5499                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5500                                     std::string ex(str, iter.base());
   5501                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5502                                     assert(ios.width() == 0);
   5503                                 }
   5504                                 ios.width(25);
   5505                                 left(ios);
   5506                                 {
   5507                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5508                                     std::string ex(str, iter.base());
   5509                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5510                                     assert(ios.width() == 0);
   5511                                 }
   5512                                 ios.width(25);
   5513                                 right(ios);
   5514                                 {
   5515                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5516                                     std::string ex(str, iter.base());
   5517                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5518                                     assert(ios.width() == 0);
   5519                                 }
   5520                                 ios.width(25);
   5521                                 internal(ios);
   5522                                 {
   5523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5524                                     std::string ex(str, iter.base());
   5525                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5526                                     assert(ios.width() == 0);
   5527                                 }
   5528                             }
   5529                         }
   5530                     }
   5531                     showpos(ios);
   5532                     {
   5533                         noshowpoint(ios);
   5534                         {
   5535                             ios.imbue(lc);
   5536                             {
   5537                                 ios.width(0);
   5538                                 {
   5539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5540                                     std::string ex(str, iter.base());
   5541                                     assert(ex == "-0");
   5542                                     assert(ios.width() == 0);
   5543                                 }
   5544                                 ios.width(25);
   5545                                 left(ios);
   5546                                 {
   5547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5548                                     std::string ex(str, iter.base());
   5549                                     assert(ex == "-0***********************");
   5550                                     assert(ios.width() == 0);
   5551                                 }
   5552                                 ios.width(25);
   5553                                 right(ios);
   5554                                 {
   5555                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5556                                     std::string ex(str, iter.base());
   5557                                     assert(ex == "***********************-0");
   5558                                     assert(ios.width() == 0);
   5559                                 }
   5560                                 ios.width(25);
   5561                                 internal(ios);
   5562                                 {
   5563                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5564                                     std::string ex(str, iter.base());
   5565                                     assert(ex == "-***********************0");
   5566                                     assert(ios.width() == 0);
   5567                                 }
   5568                             }
   5569                             ios.imbue(lg);
   5570                             {
   5571                                 ios.width(0);
   5572                                 {
   5573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5574                                     std::string ex(str, iter.base());
   5575                                     assert(ex == "-0");
   5576                                     assert(ios.width() == 0);
   5577                                 }
   5578                                 ios.width(25);
   5579                                 left(ios);
   5580                                 {
   5581                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5582                                     std::string ex(str, iter.base());
   5583                                     assert(ex == "-0***********************");
   5584                                     assert(ios.width() == 0);
   5585                                 }
   5586                                 ios.width(25);
   5587                                 right(ios);
   5588                                 {
   5589                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5590                                     std::string ex(str, iter.base());
   5591                                     assert(ex == "***********************-0");
   5592                                     assert(ios.width() == 0);
   5593                                 }
   5594                                 ios.width(25);
   5595                                 internal(ios);
   5596                                 {
   5597                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5598                                     std::string ex(str, iter.base());
   5599                                     assert(ex == "-***********************0");
   5600                                     assert(ios.width() == 0);
   5601                                 }
   5602                             }
   5603                         }
   5604                         showpoint(ios);
   5605                         {
   5606                             ios.imbue(lc);
   5607                             {
   5608                                 ios.width(0);
   5609                                 {
   5610                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5611                                     std::string ex(str, iter.base());
   5612                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5613                                     assert(ios.width() == 0);
   5614                                 }
   5615                                 ios.width(25);
   5616                                 left(ios);
   5617                                 {
   5618                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5619                                     std::string ex(str, iter.base());
   5620                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5621                                     assert(ios.width() == 0);
   5622                                 }
   5623                                 ios.width(25);
   5624                                 right(ios);
   5625                                 {
   5626                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5627                                     std::string ex(str, iter.base());
   5628                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5629                                     assert(ios.width() == 0);
   5630                                 }
   5631                                 ios.width(25);
   5632                                 internal(ios);
   5633                                 {
   5634                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5635                                     std::string ex(str, iter.base());
   5636                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5637                                     assert(ios.width() == 0);
   5638                                 }
   5639                             }
   5640                             ios.imbue(lg);
   5641                             {
   5642                                 ios.width(0);
   5643                                 {
   5644                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5645                                     std::string ex(str, iter.base());
   5646                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5647                                     assert(ios.width() == 0);
   5648                                 }
   5649                                 ios.width(25);
   5650                                 left(ios);
   5651                                 {
   5652                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5653                                     std::string ex(str, iter.base());
   5654                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5655                                     assert(ios.width() == 0);
   5656                                 }
   5657                                 ios.width(25);
   5658                                 right(ios);
   5659                                 {
   5660                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5661                                     std::string ex(str, iter.base());
   5662                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5663                                     assert(ios.width() == 0);
   5664                                 }
   5665                                 ios.width(25);
   5666                                 internal(ios);
   5667                                 {
   5668                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5669                                     std::string ex(str, iter.base());
   5670                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5671                                     assert(ios.width() == 0);
   5672                                 }
   5673                             }
   5674                         }
   5675                     }
   5676                 }
   5677                 uppercase(ios);
   5678                 {
   5679                     noshowpos(ios);
   5680                     {
   5681                         noshowpoint(ios);
   5682                         {
   5683                             ios.imbue(lc);
   5684                             {
   5685                                 ios.width(0);
   5686                                 {
   5687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5688                                     std::string ex(str, iter.base());
   5689                                     assert(ex == "-0");
   5690                                     assert(ios.width() == 0);
   5691                                 }
   5692                                 ios.width(25);
   5693                                 left(ios);
   5694                                 {
   5695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5696                                     std::string ex(str, iter.base());
   5697                                     assert(ex == "-0***********************");
   5698                                     assert(ios.width() == 0);
   5699                                 }
   5700                                 ios.width(25);
   5701                                 right(ios);
   5702                                 {
   5703                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5704                                     std::string ex(str, iter.base());
   5705                                     assert(ex == "***********************-0");
   5706                                     assert(ios.width() == 0);
   5707                                 }
   5708                                 ios.width(25);
   5709                                 internal(ios);
   5710                                 {
   5711                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5712                                     std::string ex(str, iter.base());
   5713                                     assert(ex == "-***********************0");
   5714                                     assert(ios.width() == 0);
   5715                                 }
   5716                             }
   5717                             ios.imbue(lg);
   5718                             {
   5719                                 ios.width(0);
   5720                                 {
   5721                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5722                                     std::string ex(str, iter.base());
   5723                                     assert(ex == "-0");
   5724                                     assert(ios.width() == 0);
   5725                                 }
   5726                                 ios.width(25);
   5727                                 left(ios);
   5728                                 {
   5729                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5730                                     std::string ex(str, iter.base());
   5731                                     assert(ex == "-0***********************");
   5732                                     assert(ios.width() == 0);
   5733                                 }
   5734                                 ios.width(25);
   5735                                 right(ios);
   5736                                 {
   5737                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5738                                     std::string ex(str, iter.base());
   5739                                     assert(ex == "***********************-0");
   5740                                     assert(ios.width() == 0);
   5741                                 }
   5742                                 ios.width(25);
   5743                                 internal(ios);
   5744                                 {
   5745                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5746                                     std::string ex(str, iter.base());
   5747                                     assert(ex == "-***********************0");
   5748                                     assert(ios.width() == 0);
   5749                                 }
   5750                             }
   5751                         }
   5752                         showpoint(ios);
   5753                         {
   5754                             ios.imbue(lc);
   5755                             {
   5756                                 ios.width(0);
   5757                                 {
   5758                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5759                                     std::string ex(str, iter.base());
   5760                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5761                                     assert(ios.width() == 0);
   5762                                 }
   5763                                 ios.width(25);
   5764                                 left(ios);
   5765                                 {
   5766                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5767                                     std::string ex(str, iter.base());
   5768                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5769                                     assert(ios.width() == 0);
   5770                                 }
   5771                                 ios.width(25);
   5772                                 right(ios);
   5773                                 {
   5774                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5775                                     std::string ex(str, iter.base());
   5776                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5777                                     assert(ios.width() == 0);
   5778                                 }
   5779                                 ios.width(25);
   5780                                 internal(ios);
   5781                                 {
   5782                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5783                                     std::string ex(str, iter.base());
   5784                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5785                                     assert(ios.width() == 0);
   5786                                 }
   5787                             }
   5788                             ios.imbue(lg);
   5789                             {
   5790                                 ios.width(0);
   5791                                 {
   5792                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5793                                     std::string ex(str, iter.base());
   5794                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5795                                     assert(ios.width() == 0);
   5796                                 }
   5797                                 ios.width(25);
   5798                                 left(ios);
   5799                                 {
   5800                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5801                                     std::string ex(str, iter.base());
   5802                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5803                                     assert(ios.width() == 0);
   5804                                 }
   5805                                 ios.width(25);
   5806                                 right(ios);
   5807                                 {
   5808                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5809                                     std::string ex(str, iter.base());
   5810                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5811                                     assert(ios.width() == 0);
   5812                                 }
   5813                                 ios.width(25);
   5814                                 internal(ios);
   5815                                 {
   5816                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5817                                     std::string ex(str, iter.base());
   5818                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5819                                     assert(ios.width() == 0);
   5820                                 }
   5821                             }
   5822                         }
   5823                     }
   5824                     showpos(ios);
   5825                     {
   5826                         noshowpoint(ios);
   5827                         {
   5828                             ios.imbue(lc);
   5829                             {
   5830                                 ios.width(0);
   5831                                 {
   5832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5833                                     std::string ex(str, iter.base());
   5834                                     assert(ex == "-0");
   5835                                     assert(ios.width() == 0);
   5836                                 }
   5837                                 ios.width(25);
   5838                                 left(ios);
   5839                                 {
   5840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5841                                     std::string ex(str, iter.base());
   5842                                     assert(ex == "-0***********************");
   5843                                     assert(ios.width() == 0);
   5844                                 }
   5845                                 ios.width(25);
   5846                                 right(ios);
   5847                                 {
   5848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5849                                     std::string ex(str, iter.base());
   5850                                     assert(ex == "***********************-0");
   5851                                     assert(ios.width() == 0);
   5852                                 }
   5853                                 ios.width(25);
   5854                                 internal(ios);
   5855                                 {
   5856                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5857                                     std::string ex(str, iter.base());
   5858                                     assert(ex == "-***********************0");
   5859                                     assert(ios.width() == 0);
   5860                                 }
   5861                             }
   5862                             ios.imbue(lg);
   5863                             {
   5864                                 ios.width(0);
   5865                                 {
   5866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5867                                     std::string ex(str, iter.base());
   5868                                     assert(ex == "-0");
   5869                                     assert(ios.width() == 0);
   5870                                 }
   5871                                 ios.width(25);
   5872                                 left(ios);
   5873                                 {
   5874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5875                                     std::string ex(str, iter.base());
   5876                                     assert(ex == "-0***********************");
   5877                                     assert(ios.width() == 0);
   5878                                 }
   5879                                 ios.width(25);
   5880                                 right(ios);
   5881                                 {
   5882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5883                                     std::string ex(str, iter.base());
   5884                                     assert(ex == "***********************-0");
   5885                                     assert(ios.width() == 0);
   5886                                 }
   5887                                 ios.width(25);
   5888                                 internal(ios);
   5889                                 {
   5890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5891                                     std::string ex(str, iter.base());
   5892                                     assert(ex == "-***********************0");
   5893                                     assert(ios.width() == 0);
   5894                                 }
   5895                             }
   5896                         }
   5897                         showpoint(ios);
   5898                         {
   5899                             ios.imbue(lc);
   5900                             {
   5901                                 ios.width(0);
   5902                                 {
   5903                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5904                                     std::string ex(str, iter.base());
   5905                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5906                                     assert(ios.width() == 0);
   5907                                 }
   5908                                 ios.width(25);
   5909                                 left(ios);
   5910                                 {
   5911                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5912                                     std::string ex(str, iter.base());
   5913                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5914                                     assert(ios.width() == 0);
   5915                                 }
   5916                                 ios.width(25);
   5917                                 right(ios);
   5918                                 {
   5919                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5920                                     std::string ex(str, iter.base());
   5921                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5922                                     assert(ios.width() == 0);
   5923                                 }
   5924                                 ios.width(25);
   5925                                 internal(ios);
   5926                                 {
   5927                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5928                                     std::string ex(str, iter.base());
   5929                                     assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000");
   5930                                     assert(ios.width() == 0);
   5931                                 }
   5932                             }
   5933                             ios.imbue(lg);
   5934                             {
   5935                                 ios.width(0);
   5936                                 {
   5937                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5938                                     std::string ex(str, iter.base());
   5939                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5940                                     assert(ios.width() == 0);
   5941                                 }
   5942                                 ios.width(25);
   5943                                 left(ios);
   5944                                 {
   5945                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5946                                     std::string ex(str, iter.base());
   5947                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5948                                     assert(ios.width() == 0);
   5949                                 }
   5950                                 ios.width(25);
   5951                                 right(ios);
   5952                                 {
   5953                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5954                                     std::string ex(str, iter.base());
   5955                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5956                                     assert(ios.width() == 0);
   5957                                 }
   5958                                 ios.width(25);
   5959                                 internal(ios);
   5960                                 {
   5961                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   5962                                     std::string ex(str, iter.base());
   5963                                     assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000");
   5964                                     assert(ios.width() == 0);
   5965                                 }
   5966                             }
   5967                         }
   5968                     }
   5969                 }
   5970             }
   5971         }
   5972     }
   5973 }
   5974 
   5975 void test3()
   5976 {
   5977     char str[200];
   5978     output_iterator<char*> iter;
   5979     std::locale lc = std::locale::classic();
   5980     std::locale lg(lc, new my_numpunct);
   5981     const my_facet f(1);
   5982     {
   5983         long double v = 1234567890.125;
   5984         std::ios ios(0);
   5985         // %g
   5986         {
   5987             ios.precision(0);
   5988             {
   5989                 nouppercase(ios);
   5990                 {
   5991                     noshowpos(ios);
   5992                     {
   5993                         noshowpoint(ios);
   5994                         {
   5995                             ios.imbue(lc);
   5996                             {
   5997                                 ios.width(0);
   5998                                 {
   5999                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6000                                     std::string ex(str, iter.base());
   6001                                     assert(ex == "1e+09");
   6002                                     assert(ios.width() == 0);
   6003                                 }
   6004                                 ios.width(25);
   6005                                 left(ios);
   6006                                 {
   6007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6008                                     std::string ex(str, iter.base());
   6009                                     assert(ex == "1e+09********************");
   6010                                     assert(ios.width() == 0);
   6011                                 }
   6012                                 ios.width(25);
   6013                                 right(ios);
   6014                                 {
   6015                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6016                                     std::string ex(str, iter.base());
   6017                                     assert(ex == "********************1e+09");
   6018                                     assert(ios.width() == 0);
   6019                                 }
   6020                                 ios.width(25);
   6021                                 internal(ios);
   6022                                 {
   6023                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6024                                     std::string ex(str, iter.base());
   6025                                     assert(ex == "********************1e+09");
   6026                                     assert(ios.width() == 0);
   6027                                 }
   6028                             }
   6029                             ios.imbue(lg);
   6030                             {
   6031                                 ios.width(0);
   6032                                 {
   6033                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6034                                     std::string ex(str, iter.base());
   6035                                     assert(ex == "1e+09");
   6036                                     assert(ios.width() == 0);
   6037                                 }
   6038                                 ios.width(25);
   6039                                 left(ios);
   6040                                 {
   6041                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6042                                     std::string ex(str, iter.base());
   6043                                     assert(ex == "1e+09********************");
   6044                                     assert(ios.width() == 0);
   6045                                 }
   6046                                 ios.width(25);
   6047                                 right(ios);
   6048                                 {
   6049                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6050                                     std::string ex(str, iter.base());
   6051                                     assert(ex == "********************1e+09");
   6052                                     assert(ios.width() == 0);
   6053                                 }
   6054                                 ios.width(25);
   6055                                 internal(ios);
   6056                                 {
   6057                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6058                                     std::string ex(str, iter.base());
   6059                                     assert(ex == "********************1e+09");
   6060                                     assert(ios.width() == 0);
   6061                                 }
   6062                             }
   6063                         }
   6064                         showpoint(ios);
   6065                         {
   6066                             ios.imbue(lc);
   6067                             {
   6068                                 ios.width(0);
   6069                                 {
   6070                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6071                                     std::string ex(str, iter.base());
   6072                                     assert(ex == "1.e+09");
   6073                                     assert(ios.width() == 0);
   6074                                 }
   6075                                 ios.width(25);
   6076                                 left(ios);
   6077                                 {
   6078                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6079                                     std::string ex(str, iter.base());
   6080                                     assert(ex == "1.e+09*******************");
   6081                                     assert(ios.width() == 0);
   6082                                 }
   6083                                 ios.width(25);
   6084                                 right(ios);
   6085                                 {
   6086                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6087                                     std::string ex(str, iter.base());
   6088                                     assert(ex == "*******************1.e+09");
   6089                                     assert(ios.width() == 0);
   6090                                 }
   6091                                 ios.width(25);
   6092                                 internal(ios);
   6093                                 {
   6094                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6095                                     std::string ex(str, iter.base());
   6096                                     assert(ex == "*******************1.e+09");
   6097                                     assert(ios.width() == 0);
   6098                                 }
   6099                             }
   6100                             ios.imbue(lg);
   6101                             {
   6102                                 ios.width(0);
   6103                                 {
   6104                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6105                                     std::string ex(str, iter.base());
   6106                                     assert(ex == "1;e+09");
   6107                                     assert(ios.width() == 0);
   6108                                 }
   6109                                 ios.width(25);
   6110                                 left(ios);
   6111                                 {
   6112                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6113                                     std::string ex(str, iter.base());
   6114                                     assert(ex == "1;e+09*******************");
   6115                                     assert(ios.width() == 0);
   6116                                 }
   6117                                 ios.width(25);
   6118                                 right(ios);
   6119                                 {
   6120                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6121                                     std::string ex(str, iter.base());
   6122                                     assert(ex == "*******************1;e+09");
   6123                                     assert(ios.width() == 0);
   6124                                 }
   6125                                 ios.width(25);
   6126                                 internal(ios);
   6127                                 {
   6128                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6129                                     std::string ex(str, iter.base());
   6130                                     assert(ex == "*******************1;e+09");
   6131                                     assert(ios.width() == 0);
   6132                                 }
   6133                             }
   6134                         }
   6135                     }
   6136                     showpos(ios);
   6137                     {
   6138                         noshowpoint(ios);
   6139                         {
   6140                             ios.imbue(lc);
   6141                             {
   6142                                 ios.width(0);
   6143                                 {
   6144                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6145                                     std::string ex(str, iter.base());
   6146                                     assert(ex == "+1e+09");
   6147                                     assert(ios.width() == 0);
   6148                                 }
   6149                                 ios.width(25);
   6150                                 left(ios);
   6151                                 {
   6152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6153                                     std::string ex(str, iter.base());
   6154                                     assert(ex == "+1e+09*******************");
   6155                                     assert(ios.width() == 0);
   6156                                 }
   6157                                 ios.width(25);
   6158                                 right(ios);
   6159                                 {
   6160                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6161                                     std::string ex(str, iter.base());
   6162                                     assert(ex == "*******************+1e+09");
   6163                                     assert(ios.width() == 0);
   6164                                 }
   6165                                 ios.width(25);
   6166                                 internal(ios);
   6167                                 {
   6168                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6169                                     std::string ex(str, iter.base());
   6170                                     assert(ex == "+*******************1e+09");
   6171                                     assert(ios.width() == 0);
   6172                                 }
   6173                             }
   6174                             ios.imbue(lg);
   6175                             {
   6176                                 ios.width(0);
   6177                                 {
   6178                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6179                                     std::string ex(str, iter.base());
   6180                                     assert(ex == "+1e+09");
   6181                                     assert(ios.width() == 0);
   6182                                 }
   6183                                 ios.width(25);
   6184                                 left(ios);
   6185                                 {
   6186                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6187                                     std::string ex(str, iter.base());
   6188                                     assert(ex == "+1e+09*******************");
   6189                                     assert(ios.width() == 0);
   6190                                 }
   6191                                 ios.width(25);
   6192                                 right(ios);
   6193                                 {
   6194                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6195                                     std::string ex(str, iter.base());
   6196                                     assert(ex == "*******************+1e+09");
   6197                                     assert(ios.width() == 0);
   6198                                 }
   6199                                 ios.width(25);
   6200                                 internal(ios);
   6201                                 {
   6202                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6203                                     std::string ex(str, iter.base());
   6204                                     assert(ex == "+*******************1e+09");
   6205                                     assert(ios.width() == 0);
   6206                                 }
   6207                             }
   6208                         }
   6209                         showpoint(ios);
   6210                         {
   6211                             ios.imbue(lc);
   6212                             {
   6213                                 ios.width(0);
   6214                                 {
   6215                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6216                                     std::string ex(str, iter.base());
   6217                                     assert(ex == "+1.e+09");
   6218                                     assert(ios.width() == 0);
   6219                                 }
   6220                                 ios.width(25);
   6221                                 left(ios);
   6222                                 {
   6223                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6224                                     std::string ex(str, iter.base());
   6225                                     assert(ex == "+1.e+09******************");
   6226                                     assert(ios.width() == 0);
   6227                                 }
   6228                                 ios.width(25);
   6229                                 right(ios);
   6230                                 {
   6231                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6232                                     std::string ex(str, iter.base());
   6233                                     assert(ex == "******************+1.e+09");
   6234                                     assert(ios.width() == 0);
   6235                                 }
   6236                                 ios.width(25);
   6237                                 internal(ios);
   6238                                 {
   6239                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6240                                     std::string ex(str, iter.base());
   6241                                     assert(ex == "+******************1.e+09");
   6242                                     assert(ios.width() == 0);
   6243                                 }
   6244                             }
   6245                             ios.imbue(lg);
   6246                             {
   6247                                 ios.width(0);
   6248                                 {
   6249                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6250                                     std::string ex(str, iter.base());
   6251                                     assert(ex == "+1;e+09");
   6252                                     assert(ios.width() == 0);
   6253                                 }
   6254                                 ios.width(25);
   6255                                 left(ios);
   6256                                 {
   6257                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6258                                     std::string ex(str, iter.base());
   6259                                     assert(ex == "+1;e+09******************");
   6260                                     assert(ios.width() == 0);
   6261                                 }
   6262                                 ios.width(25);
   6263                                 right(ios);
   6264                                 {
   6265                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6266                                     std::string ex(str, iter.base());
   6267                                     assert(ex == "******************+1;e+09");
   6268                                     assert(ios.width() == 0);
   6269                                 }
   6270                                 ios.width(25);
   6271                                 internal(ios);
   6272                                 {
   6273                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6274                                     std::string ex(str, iter.base());
   6275                                     assert(ex == "+******************1;e+09");
   6276                                     assert(ios.width() == 0);
   6277                                 }
   6278                             }
   6279                         }
   6280                     }
   6281                 }
   6282                 uppercase(ios);
   6283                 {
   6284                     noshowpos(ios);
   6285                     {
   6286                         noshowpoint(ios);
   6287                         {
   6288                             ios.imbue(lc);
   6289                             {
   6290                                 ios.width(0);
   6291                                 {
   6292                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6293                                     std::string ex(str, iter.base());
   6294                                     assert(ex == "1E+09");
   6295                                     assert(ios.width() == 0);
   6296                                 }
   6297                                 ios.width(25);
   6298                                 left(ios);
   6299                                 {
   6300                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6301                                     std::string ex(str, iter.base());
   6302                                     assert(ex == "1E+09********************");
   6303                                     assert(ios.width() == 0);
   6304                                 }
   6305                                 ios.width(25);
   6306                                 right(ios);
   6307                                 {
   6308                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6309                                     std::string ex(str, iter.base());
   6310                                     assert(ex == "********************1E+09");
   6311                                     assert(ios.width() == 0);
   6312                                 }
   6313                                 ios.width(25);
   6314                                 internal(ios);
   6315                                 {
   6316                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6317                                     std::string ex(str, iter.base());
   6318                                     assert(ex == "********************1E+09");
   6319                                     assert(ios.width() == 0);
   6320                                 }
   6321                             }
   6322                             ios.imbue(lg);
   6323                             {
   6324                                 ios.width(0);
   6325                                 {
   6326                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6327                                     std::string ex(str, iter.base());
   6328                                     assert(ex == "1E+09");
   6329                                     assert(ios.width() == 0);
   6330                                 }
   6331                                 ios.width(25);
   6332                                 left(ios);
   6333                                 {
   6334                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6335                                     std::string ex(str, iter.base());
   6336                                     assert(ex == "1E+09********************");
   6337                                     assert(ios.width() == 0);
   6338                                 }
   6339                                 ios.width(25);
   6340                                 right(ios);
   6341                                 {
   6342                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6343                                     std::string ex(str, iter.base());
   6344                                     assert(ex == "********************1E+09");
   6345                                     assert(ios.width() == 0);
   6346                                 }
   6347                                 ios.width(25);
   6348                                 internal(ios);
   6349                                 {
   6350                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6351                                     std::string ex(str, iter.base());
   6352                                     assert(ex == "********************1E+09");
   6353                                     assert(ios.width() == 0);
   6354                                 }
   6355                             }
   6356                         }
   6357                         showpoint(ios);
   6358                         {
   6359                             ios.imbue(lc);
   6360                             {
   6361                                 ios.width(0);
   6362                                 {
   6363                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6364                                     std::string ex(str, iter.base());
   6365                                     assert(ex == "1.E+09");
   6366                                     assert(ios.width() == 0);
   6367                                 }
   6368                                 ios.width(25);
   6369                                 left(ios);
   6370                                 {
   6371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6372                                     std::string ex(str, iter.base());
   6373                                     assert(ex == "1.E+09*******************");
   6374                                     assert(ios.width() == 0);
   6375                                 }
   6376                                 ios.width(25);
   6377                                 right(ios);
   6378                                 {
   6379                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6380                                     std::string ex(str, iter.base());
   6381                                     assert(ex == "*******************1.E+09");
   6382                                     assert(ios.width() == 0);
   6383                                 }
   6384                                 ios.width(25);
   6385                                 internal(ios);
   6386                                 {
   6387                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6388                                     std::string ex(str, iter.base());
   6389                                     assert(ex == "*******************1.E+09");
   6390                                     assert(ios.width() == 0);
   6391                                 }
   6392                             }
   6393                             ios.imbue(lg);
   6394                             {
   6395                                 ios.width(0);
   6396                                 {
   6397                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6398                                     std::string ex(str, iter.base());
   6399                                     assert(ex == "1;E+09");
   6400                                     assert(ios.width() == 0);
   6401                                 }
   6402                                 ios.width(25);
   6403                                 left(ios);
   6404                                 {
   6405                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6406                                     std::string ex(str, iter.base());
   6407                                     assert(ex == "1;E+09*******************");
   6408                                     assert(ios.width() == 0);
   6409                                 }
   6410                                 ios.width(25);
   6411                                 right(ios);
   6412                                 {
   6413                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6414                                     std::string ex(str, iter.base());
   6415                                     assert(ex == "*******************1;E+09");
   6416                                     assert(ios.width() == 0);
   6417                                 }
   6418                                 ios.width(25);
   6419                                 internal(ios);
   6420                                 {
   6421                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6422                                     std::string ex(str, iter.base());
   6423                                     assert(ex == "*******************1;E+09");
   6424                                     assert(ios.width() == 0);
   6425                                 }
   6426                             }
   6427                         }
   6428                     }
   6429                     showpos(ios);
   6430                     {
   6431                         noshowpoint(ios);
   6432                         {
   6433                             ios.imbue(lc);
   6434                             {
   6435                                 ios.width(0);
   6436                                 {
   6437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6438                                     std::string ex(str, iter.base());
   6439                                     assert(ex == "+1E+09");
   6440                                     assert(ios.width() == 0);
   6441                                 }
   6442                                 ios.width(25);
   6443                                 left(ios);
   6444                                 {
   6445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6446                                     std::string ex(str, iter.base());
   6447                                     assert(ex == "+1E+09*******************");
   6448                                     assert(ios.width() == 0);
   6449                                 }
   6450                                 ios.width(25);
   6451                                 right(ios);
   6452                                 {
   6453                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6454                                     std::string ex(str, iter.base());
   6455                                     assert(ex == "*******************+1E+09");
   6456                                     assert(ios.width() == 0);
   6457                                 }
   6458                                 ios.width(25);
   6459                                 internal(ios);
   6460                                 {
   6461                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6462                                     std::string ex(str, iter.base());
   6463                                     assert(ex == "+*******************1E+09");
   6464                                     assert(ios.width() == 0);
   6465                                 }
   6466                             }
   6467                             ios.imbue(lg);
   6468                             {
   6469                                 ios.width(0);
   6470                                 {
   6471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6472                                     std::string ex(str, iter.base());
   6473                                     assert(ex == "+1E+09");
   6474                                     assert(ios.width() == 0);
   6475                                 }
   6476                                 ios.width(25);
   6477                                 left(ios);
   6478                                 {
   6479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6480                                     std::string ex(str, iter.base());
   6481                                     assert(ex == "+1E+09*******************");
   6482                                     assert(ios.width() == 0);
   6483                                 }
   6484                                 ios.width(25);
   6485                                 right(ios);
   6486                                 {
   6487                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6488                                     std::string ex(str, iter.base());
   6489                                     assert(ex == "*******************+1E+09");
   6490                                     assert(ios.width() == 0);
   6491                                 }
   6492                                 ios.width(25);
   6493                                 internal(ios);
   6494                                 {
   6495                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6496                                     std::string ex(str, iter.base());
   6497                                     assert(ex == "+*******************1E+09");
   6498                                     assert(ios.width() == 0);
   6499                                 }
   6500                             }
   6501                         }
   6502                         showpoint(ios);
   6503                         {
   6504                             ios.imbue(lc);
   6505                             {
   6506                                 ios.width(0);
   6507                                 {
   6508                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6509                                     std::string ex(str, iter.base());
   6510                                     assert(ex == "+1.E+09");
   6511                                     assert(ios.width() == 0);
   6512                                 }
   6513                                 ios.width(25);
   6514                                 left(ios);
   6515                                 {
   6516                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6517                                     std::string ex(str, iter.base());
   6518                                     assert(ex == "+1.E+09******************");
   6519                                     assert(ios.width() == 0);
   6520                                 }
   6521                                 ios.width(25);
   6522                                 right(ios);
   6523                                 {
   6524                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6525                                     std::string ex(str, iter.base());
   6526                                     assert(ex == "******************+1.E+09");
   6527                                     assert(ios.width() == 0);
   6528                                 }
   6529                                 ios.width(25);
   6530                                 internal(ios);
   6531                                 {
   6532                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6533                                     std::string ex(str, iter.base());
   6534                                     assert(ex == "+******************1.E+09");
   6535                                     assert(ios.width() == 0);
   6536                                 }
   6537                             }
   6538                             ios.imbue(lg);
   6539                             {
   6540                                 ios.width(0);
   6541                                 {
   6542                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6543                                     std::string ex(str, iter.base());
   6544                                     assert(ex == "+1;E+09");
   6545                                     assert(ios.width() == 0);
   6546                                 }
   6547                                 ios.width(25);
   6548                                 left(ios);
   6549                                 {
   6550                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6551                                     std::string ex(str, iter.base());
   6552                                     assert(ex == "+1;E+09******************");
   6553                                     assert(ios.width() == 0);
   6554                                 }
   6555                                 ios.width(25);
   6556                                 right(ios);
   6557                                 {
   6558                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6559                                     std::string ex(str, iter.base());
   6560                                     assert(ex == "******************+1;E+09");
   6561                                     assert(ios.width() == 0);
   6562                                 }
   6563                                 ios.width(25);
   6564                                 internal(ios);
   6565                                 {
   6566                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6567                                     std::string ex(str, iter.base());
   6568                                     assert(ex == "+******************1;E+09");
   6569                                     assert(ios.width() == 0);
   6570                                 }
   6571                             }
   6572                         }
   6573                     }
   6574                 }
   6575             }
   6576             ios.precision(1);
   6577             {
   6578                 nouppercase(ios);
   6579                 {
   6580                     noshowpos(ios);
   6581                     {
   6582                         noshowpoint(ios);
   6583                         {
   6584                             ios.imbue(lc);
   6585                             {
   6586                                 ios.width(0);
   6587                                 {
   6588                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6589                                     std::string ex(str, iter.base());
   6590                                     assert(ex == "1e+09");
   6591                                     assert(ios.width() == 0);
   6592                                 }
   6593                                 ios.width(25);
   6594                                 left(ios);
   6595                                 {
   6596                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6597                                     std::string ex(str, iter.base());
   6598                                     assert(ex == "1e+09********************");
   6599                                     assert(ios.width() == 0);
   6600                                 }
   6601                                 ios.width(25);
   6602                                 right(ios);
   6603                                 {
   6604                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6605                                     std::string ex(str, iter.base());
   6606                                     assert(ex == "********************1e+09");
   6607                                     assert(ios.width() == 0);
   6608                                 }
   6609                                 ios.width(25);
   6610                                 internal(ios);
   6611                                 {
   6612                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6613                                     std::string ex(str, iter.base());
   6614                                     assert(ex == "********************1e+09");
   6615                                     assert(ios.width() == 0);
   6616                                 }
   6617                             }
   6618                             ios.imbue(lg);
   6619                             {
   6620                                 ios.width(0);
   6621                                 {
   6622                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6623                                     std::string ex(str, iter.base());
   6624                                     assert(ex == "1e+09");
   6625                                     assert(ios.width() == 0);
   6626                                 }
   6627                                 ios.width(25);
   6628                                 left(ios);
   6629                                 {
   6630                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6631                                     std::string ex(str, iter.base());
   6632                                     assert(ex == "1e+09********************");
   6633                                     assert(ios.width() == 0);
   6634                                 }
   6635                                 ios.width(25);
   6636                                 right(ios);
   6637                                 {
   6638                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6639                                     std::string ex(str, iter.base());
   6640                                     assert(ex == "********************1e+09");
   6641                                     assert(ios.width() == 0);
   6642                                 }
   6643                                 ios.width(25);
   6644                                 internal(ios);
   6645                                 {
   6646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6647                                     std::string ex(str, iter.base());
   6648                                     assert(ex == "********************1e+09");
   6649                                     assert(ios.width() == 0);
   6650                                 }
   6651                             }
   6652                         }
   6653                         showpoint(ios);
   6654                         {
   6655                             ios.imbue(lc);
   6656                             {
   6657                                 ios.width(0);
   6658                                 {
   6659                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6660                                     std::string ex(str, iter.base());
   6661                                     assert(ex == "1.e+09");
   6662                                     assert(ios.width() == 0);
   6663                                 }
   6664                                 ios.width(25);
   6665                                 left(ios);
   6666                                 {
   6667                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6668                                     std::string ex(str, iter.base());
   6669                                     assert(ex == "1.e+09*******************");
   6670                                     assert(ios.width() == 0);
   6671                                 }
   6672                                 ios.width(25);
   6673                                 right(ios);
   6674                                 {
   6675                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6676                                     std::string ex(str, iter.base());
   6677                                     assert(ex == "*******************1.e+09");
   6678                                     assert(ios.width() == 0);
   6679                                 }
   6680                                 ios.width(25);
   6681                                 internal(ios);
   6682                                 {
   6683                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6684                                     std::string ex(str, iter.base());
   6685                                     assert(ex == "*******************1.e+09");
   6686                                     assert(ios.width() == 0);
   6687                                 }
   6688                             }
   6689                             ios.imbue(lg);
   6690                             {
   6691                                 ios.width(0);
   6692                                 {
   6693                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6694                                     std::string ex(str, iter.base());
   6695                                     assert(ex == "1;e+09");
   6696                                     assert(ios.width() == 0);
   6697                                 }
   6698                                 ios.width(25);
   6699                                 left(ios);
   6700                                 {
   6701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6702                                     std::string ex(str, iter.base());
   6703                                     assert(ex == "1;e+09*******************");
   6704                                     assert(ios.width() == 0);
   6705                                 }
   6706                                 ios.width(25);
   6707                                 right(ios);
   6708                                 {
   6709                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6710                                     std::string ex(str, iter.base());
   6711                                     assert(ex == "*******************1;e+09");
   6712                                     assert(ios.width() == 0);
   6713                                 }
   6714                                 ios.width(25);
   6715                                 internal(ios);
   6716                                 {
   6717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6718                                     std::string ex(str, iter.base());
   6719                                     assert(ex == "*******************1;e+09");
   6720                                     assert(ios.width() == 0);
   6721                                 }
   6722                             }
   6723                         }
   6724                     }
   6725                     showpos(ios);
   6726                     {
   6727                         noshowpoint(ios);
   6728                         {
   6729                             ios.imbue(lc);
   6730                             {
   6731                                 ios.width(0);
   6732                                 {
   6733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6734                                     std::string ex(str, iter.base());
   6735                                     assert(ex == "+1e+09");
   6736                                     assert(ios.width() == 0);
   6737                                 }
   6738                                 ios.width(25);
   6739                                 left(ios);
   6740                                 {
   6741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6742                                     std::string ex(str, iter.base());
   6743                                     assert(ex == "+1e+09*******************");
   6744                                     assert(ios.width() == 0);
   6745                                 }
   6746                                 ios.width(25);
   6747                                 right(ios);
   6748                                 {
   6749                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6750                                     std::string ex(str, iter.base());
   6751                                     assert(ex == "*******************+1e+09");
   6752                                     assert(ios.width() == 0);
   6753                                 }
   6754                                 ios.width(25);
   6755                                 internal(ios);
   6756                                 {
   6757                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6758                                     std::string ex(str, iter.base());
   6759                                     assert(ex == "+*******************1e+09");
   6760                                     assert(ios.width() == 0);
   6761                                 }
   6762                             }
   6763                             ios.imbue(lg);
   6764                             {
   6765                                 ios.width(0);
   6766                                 {
   6767                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6768                                     std::string ex(str, iter.base());
   6769                                     assert(ex == "+1e+09");
   6770                                     assert(ios.width() == 0);
   6771                                 }
   6772                                 ios.width(25);
   6773                                 left(ios);
   6774                                 {
   6775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6776                                     std::string ex(str, iter.base());
   6777                                     assert(ex == "+1e+09*******************");
   6778                                     assert(ios.width() == 0);
   6779                                 }
   6780                                 ios.width(25);
   6781                                 right(ios);
   6782                                 {
   6783                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6784                                     std::string ex(str, iter.base());
   6785                                     assert(ex == "*******************+1e+09");
   6786                                     assert(ios.width() == 0);
   6787                                 }
   6788                                 ios.width(25);
   6789                                 internal(ios);
   6790                                 {
   6791                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6792                                     std::string ex(str, iter.base());
   6793                                     assert(ex == "+*******************1e+09");
   6794                                     assert(ios.width() == 0);
   6795                                 }
   6796                             }
   6797                         }
   6798                         showpoint(ios);
   6799                         {
   6800                             ios.imbue(lc);
   6801                             {
   6802                                 ios.width(0);
   6803                                 {
   6804                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6805                                     std::string ex(str, iter.base());
   6806                                     assert(ex == "+1.e+09");
   6807                                     assert(ios.width() == 0);
   6808                                 }
   6809                                 ios.width(25);
   6810                                 left(ios);
   6811                                 {
   6812                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6813                                     std::string ex(str, iter.base());
   6814                                     assert(ex == "+1.e+09******************");
   6815                                     assert(ios.width() == 0);
   6816                                 }
   6817                                 ios.width(25);
   6818                                 right(ios);
   6819                                 {
   6820                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6821                                     std::string ex(str, iter.base());
   6822                                     assert(ex == "******************+1.e+09");
   6823                                     assert(ios.width() == 0);
   6824                                 }
   6825                                 ios.width(25);
   6826                                 internal(ios);
   6827                                 {
   6828                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6829                                     std::string ex(str, iter.base());
   6830                                     assert(ex == "+******************1.e+09");
   6831                                     assert(ios.width() == 0);
   6832                                 }
   6833                             }
   6834                             ios.imbue(lg);
   6835                             {
   6836                                 ios.width(0);
   6837                                 {
   6838                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6839                                     std::string ex(str, iter.base());
   6840                                     assert(ex == "+1;e+09");
   6841                                     assert(ios.width() == 0);
   6842                                 }
   6843                                 ios.width(25);
   6844                                 left(ios);
   6845                                 {
   6846                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6847                                     std::string ex(str, iter.base());
   6848                                     assert(ex == "+1;e+09******************");
   6849                                     assert(ios.width() == 0);
   6850                                 }
   6851                                 ios.width(25);
   6852                                 right(ios);
   6853                                 {
   6854                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6855                                     std::string ex(str, iter.base());
   6856                                     assert(ex == "******************+1;e+09");
   6857                                     assert(ios.width() == 0);
   6858                                 }
   6859                                 ios.width(25);
   6860                                 internal(ios);
   6861                                 {
   6862                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6863                                     std::string ex(str, iter.base());
   6864                                     assert(ex == "+******************1;e+09");
   6865                                     assert(ios.width() == 0);
   6866                                 }
   6867                             }
   6868                         }
   6869                     }
   6870                 }
   6871                 uppercase(ios);
   6872                 {
   6873                     noshowpos(ios);
   6874                     {
   6875                         noshowpoint(ios);
   6876                         {
   6877                             ios.imbue(lc);
   6878                             {
   6879                                 ios.width(0);
   6880                                 {
   6881                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6882                                     std::string ex(str, iter.base());
   6883                                     assert(ex == "1E+09");
   6884                                     assert(ios.width() == 0);
   6885                                 }
   6886                                 ios.width(25);
   6887                                 left(ios);
   6888                                 {
   6889                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6890                                     std::string ex(str, iter.base());
   6891                                     assert(ex == "1E+09********************");
   6892                                     assert(ios.width() == 0);
   6893                                 }
   6894                                 ios.width(25);
   6895                                 right(ios);
   6896                                 {
   6897                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6898                                     std::string ex(str, iter.base());
   6899                                     assert(ex == "********************1E+09");
   6900                                     assert(ios.width() == 0);
   6901                                 }
   6902                                 ios.width(25);
   6903                                 internal(ios);
   6904                                 {
   6905                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6906                                     std::string ex(str, iter.base());
   6907                                     assert(ex == "********************1E+09");
   6908                                     assert(ios.width() == 0);
   6909                                 }
   6910                             }
   6911                             ios.imbue(lg);
   6912                             {
   6913                                 ios.width(0);
   6914                                 {
   6915                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6916                                     std::string ex(str, iter.base());
   6917                                     assert(ex == "1E+09");
   6918                                     assert(ios.width() == 0);
   6919                                 }
   6920                                 ios.width(25);
   6921                                 left(ios);
   6922                                 {
   6923                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6924                                     std::string ex(str, iter.base());
   6925                                     assert(ex == "1E+09********************");
   6926                                     assert(ios.width() == 0);
   6927                                 }
   6928                                 ios.width(25);
   6929                                 right(ios);
   6930                                 {
   6931                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6932                                     std::string ex(str, iter.base());
   6933                                     assert(ex == "********************1E+09");
   6934                                     assert(ios.width() == 0);
   6935                                 }
   6936                                 ios.width(25);
   6937                                 internal(ios);
   6938                                 {
   6939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6940                                     std::string ex(str, iter.base());
   6941                                     assert(ex == "********************1E+09");
   6942                                     assert(ios.width() == 0);
   6943                                 }
   6944                             }
   6945                         }
   6946                         showpoint(ios);
   6947                         {
   6948                             ios.imbue(lc);
   6949                             {
   6950                                 ios.width(0);
   6951                                 {
   6952                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6953                                     std::string ex(str, iter.base());
   6954                                     assert(ex == "1.E+09");
   6955                                     assert(ios.width() == 0);
   6956                                 }
   6957                                 ios.width(25);
   6958                                 left(ios);
   6959                                 {
   6960                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6961                                     std::string ex(str, iter.base());
   6962                                     assert(ex == "1.E+09*******************");
   6963                                     assert(ios.width() == 0);
   6964                                 }
   6965                                 ios.width(25);
   6966                                 right(ios);
   6967                                 {
   6968                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6969                                     std::string ex(str, iter.base());
   6970                                     assert(ex == "*******************1.E+09");
   6971                                     assert(ios.width() == 0);
   6972                                 }
   6973                                 ios.width(25);
   6974                                 internal(ios);
   6975                                 {
   6976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6977                                     std::string ex(str, iter.base());
   6978                                     assert(ex == "*******************1.E+09");
   6979                                     assert(ios.width() == 0);
   6980                                 }
   6981                             }
   6982                             ios.imbue(lg);
   6983                             {
   6984                                 ios.width(0);
   6985                                 {
   6986                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6987                                     std::string ex(str, iter.base());
   6988                                     assert(ex == "1;E+09");
   6989                                     assert(ios.width() == 0);
   6990                                 }
   6991                                 ios.width(25);
   6992                                 left(ios);
   6993                                 {
   6994                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   6995                                     std::string ex(str, iter.base());
   6996                                     assert(ex == "1;E+09*******************");
   6997                                     assert(ios.width() == 0);
   6998                                 }
   6999                                 ios.width(25);
   7000                                 right(ios);
   7001                                 {
   7002                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7003                                     std::string ex(str, iter.base());
   7004                                     assert(ex == "*******************1;E+09");
   7005                                     assert(ios.width() == 0);
   7006                                 }
   7007                                 ios.width(25);
   7008                                 internal(ios);
   7009                                 {
   7010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7011                                     std::string ex(str, iter.base());
   7012                                     assert(ex == "*******************1;E+09");
   7013                                     assert(ios.width() == 0);
   7014                                 }
   7015                             }
   7016                         }
   7017                     }
   7018                     showpos(ios);
   7019                     {
   7020                         noshowpoint(ios);
   7021                         {
   7022                             ios.imbue(lc);
   7023                             {
   7024                                 ios.width(0);
   7025                                 {
   7026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7027                                     std::string ex(str, iter.base());
   7028                                     assert(ex == "+1E+09");
   7029                                     assert(ios.width() == 0);
   7030                                 }
   7031                                 ios.width(25);
   7032                                 left(ios);
   7033                                 {
   7034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7035                                     std::string ex(str, iter.base());
   7036                                     assert(ex == "+1E+09*******************");
   7037                                     assert(ios.width() == 0);
   7038                                 }
   7039                                 ios.width(25);
   7040                                 right(ios);
   7041                                 {
   7042                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7043                                     std::string ex(str, iter.base());
   7044                                     assert(ex == "*******************+1E+09");
   7045                                     assert(ios.width() == 0);
   7046                                 }
   7047                                 ios.width(25);
   7048                                 internal(ios);
   7049                                 {
   7050                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7051                                     std::string ex(str, iter.base());
   7052                                     assert(ex == "+*******************1E+09");
   7053                                     assert(ios.width() == 0);
   7054                                 }
   7055                             }
   7056                             ios.imbue(lg);
   7057                             {
   7058                                 ios.width(0);
   7059                                 {
   7060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7061                                     std::string ex(str, iter.base());
   7062                                     assert(ex == "+1E+09");
   7063                                     assert(ios.width() == 0);
   7064                                 }
   7065                                 ios.width(25);
   7066                                 left(ios);
   7067                                 {
   7068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7069                                     std::string ex(str, iter.base());
   7070                                     assert(ex == "+1E+09*******************");
   7071                                     assert(ios.width() == 0);
   7072                                 }
   7073                                 ios.width(25);
   7074                                 right(ios);
   7075                                 {
   7076                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7077                                     std::string ex(str, iter.base());
   7078                                     assert(ex == "*******************+1E+09");
   7079                                     assert(ios.width() == 0);
   7080                                 }
   7081                                 ios.width(25);
   7082                                 internal(ios);
   7083                                 {
   7084                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7085                                     std::string ex(str, iter.base());
   7086                                     assert(ex == "+*******************1E+09");
   7087                                     assert(ios.width() == 0);
   7088                                 }
   7089                             }
   7090                         }
   7091                         showpoint(ios);
   7092                         {
   7093                             ios.imbue(lc);
   7094                             {
   7095                                 ios.width(0);
   7096                                 {
   7097                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7098                                     std::string ex(str, iter.base());
   7099                                     assert(ex == "+1.E+09");
   7100                                     assert(ios.width() == 0);
   7101                                 }
   7102                                 ios.width(25);
   7103                                 left(ios);
   7104                                 {
   7105                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7106                                     std::string ex(str, iter.base());
   7107                                     assert(ex == "+1.E+09******************");
   7108                                     assert(ios.width() == 0);
   7109                                 }
   7110                                 ios.width(25);
   7111                                 right(ios);
   7112                                 {
   7113                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7114                                     std::string ex(str, iter.base());
   7115                                     assert(ex == "******************+1.E+09");
   7116                                     assert(ios.width() == 0);
   7117                                 }
   7118                                 ios.width(25);
   7119                                 internal(ios);
   7120                                 {
   7121                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7122                                     std::string ex(str, iter.base());
   7123                                     assert(ex == "+******************1.E+09");
   7124                                     assert(ios.width() == 0);
   7125                                 }
   7126                             }
   7127                             ios.imbue(lg);
   7128                             {
   7129                                 ios.width(0);
   7130                                 {
   7131                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7132                                     std::string ex(str, iter.base());
   7133                                     assert(ex == "+1;E+09");
   7134                                     assert(ios.width() == 0);
   7135                                 }
   7136                                 ios.width(25);
   7137                                 left(ios);
   7138                                 {
   7139                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7140                                     std::string ex(str, iter.base());
   7141                                     assert(ex == "+1;E+09******************");
   7142                                     assert(ios.width() == 0);
   7143                                 }
   7144                                 ios.width(25);
   7145                                 right(ios);
   7146                                 {
   7147                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7148                                     std::string ex(str, iter.base());
   7149                                     assert(ex == "******************+1;E+09");
   7150                                     assert(ios.width() == 0);
   7151                                 }
   7152                                 ios.width(25);
   7153                                 internal(ios);
   7154                                 {
   7155                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7156                                     std::string ex(str, iter.base());
   7157                                     assert(ex == "+******************1;E+09");
   7158                                     assert(ios.width() == 0);
   7159                                 }
   7160                             }
   7161                         }
   7162                     }
   7163                 }
   7164             }
   7165             ios.precision(6);
   7166             {
   7167                 nouppercase(ios);
   7168                 {
   7169                     noshowpos(ios);
   7170                     {
   7171                         noshowpoint(ios);
   7172                         {
   7173                             ios.imbue(lc);
   7174                             {
   7175                                 ios.width(0);
   7176                                 {
   7177                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7178                                     std::string ex(str, iter.base());
   7179                                     assert(ex == "1.23457e+09");
   7180                                     assert(ios.width() == 0);
   7181                                 }
   7182                                 ios.width(25);
   7183                                 left(ios);
   7184                                 {
   7185                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7186                                     std::string ex(str, iter.base());
   7187                                     assert(ex == "1.23457e+09**************");
   7188                                     assert(ios.width() == 0);
   7189                                 }
   7190                                 ios.width(25);
   7191                                 right(ios);
   7192                                 {
   7193                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7194                                     std::string ex(str, iter.base());
   7195                                     assert(ex == "**************1.23457e+09");
   7196                                     assert(ios.width() == 0);
   7197                                 }
   7198                                 ios.width(25);
   7199                                 internal(ios);
   7200                                 {
   7201                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7202                                     std::string ex(str, iter.base());
   7203                                     assert(ex == "**************1.23457e+09");
   7204                                     assert(ios.width() == 0);
   7205                                 }
   7206                             }
   7207                             ios.imbue(lg);
   7208                             {
   7209                                 ios.width(0);
   7210                                 {
   7211                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7212                                     std::string ex(str, iter.base());
   7213                                     assert(ex == "1;23457e+09");
   7214                                     assert(ios.width() == 0);
   7215                                 }
   7216                                 ios.width(25);
   7217                                 left(ios);
   7218                                 {
   7219                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7220                                     std::string ex(str, iter.base());
   7221                                     assert(ex == "1;23457e+09**************");
   7222                                     assert(ios.width() == 0);
   7223                                 }
   7224                                 ios.width(25);
   7225                                 right(ios);
   7226                                 {
   7227                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7228                                     std::string ex(str, iter.base());
   7229                                     assert(ex == "**************1;23457e+09");
   7230                                     assert(ios.width() == 0);
   7231                                 }
   7232                                 ios.width(25);
   7233                                 internal(ios);
   7234                                 {
   7235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7236                                     std::string ex(str, iter.base());
   7237                                     assert(ex == "**************1;23457e+09");
   7238                                     assert(ios.width() == 0);
   7239                                 }
   7240                             }
   7241                         }
   7242                         showpoint(ios);
   7243                         {
   7244                             ios.imbue(lc);
   7245                             {
   7246                                 ios.width(0);
   7247                                 {
   7248                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7249                                     std::string ex(str, iter.base());
   7250                                     assert(ex == "1.23457e+09");
   7251                                     assert(ios.width() == 0);
   7252                                 }
   7253                                 ios.width(25);
   7254                                 left(ios);
   7255                                 {
   7256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7257                                     std::string ex(str, iter.base());
   7258                                     assert(ex == "1.23457e+09**************");
   7259                                     assert(ios.width() == 0);
   7260                                 }
   7261                                 ios.width(25);
   7262                                 right(ios);
   7263                                 {
   7264                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7265                                     std::string ex(str, iter.base());
   7266                                     assert(ex == "**************1.23457e+09");
   7267                                     assert(ios.width() == 0);
   7268                                 }
   7269                                 ios.width(25);
   7270                                 internal(ios);
   7271                                 {
   7272                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7273                                     std::string ex(str, iter.base());
   7274                                     assert(ex == "**************1.23457e+09");
   7275                                     assert(ios.width() == 0);
   7276                                 }
   7277                             }
   7278                             ios.imbue(lg);
   7279                             {
   7280                                 ios.width(0);
   7281                                 {
   7282                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7283                                     std::string ex(str, iter.base());
   7284                                     assert(ex == "1;23457e+09");
   7285                                     assert(ios.width() == 0);
   7286                                 }
   7287                                 ios.width(25);
   7288                                 left(ios);
   7289                                 {
   7290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7291                                     std::string ex(str, iter.base());
   7292                                     assert(ex == "1;23457e+09**************");
   7293                                     assert(ios.width() == 0);
   7294                                 }
   7295                                 ios.width(25);
   7296                                 right(ios);
   7297                                 {
   7298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7299                                     std::string ex(str, iter.base());
   7300                                     assert(ex == "**************1;23457e+09");
   7301                                     assert(ios.width() == 0);
   7302                                 }
   7303                                 ios.width(25);
   7304                                 internal(ios);
   7305                                 {
   7306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7307                                     std::string ex(str, iter.base());
   7308                                     assert(ex == "**************1;23457e+09");
   7309                                     assert(ios.width() == 0);
   7310                                 }
   7311                             }
   7312                         }
   7313                     }
   7314                     showpos(ios);
   7315                     {
   7316                         noshowpoint(ios);
   7317                         {
   7318                             ios.imbue(lc);
   7319                             {
   7320                                 ios.width(0);
   7321                                 {
   7322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7323                                     std::string ex(str, iter.base());
   7324                                     assert(ex == "+1.23457e+09");
   7325                                     assert(ios.width() == 0);
   7326                                 }
   7327                                 ios.width(25);
   7328                                 left(ios);
   7329                                 {
   7330                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7331                                     std::string ex(str, iter.base());
   7332                                     assert(ex == "+1.23457e+09*************");
   7333                                     assert(ios.width() == 0);
   7334                                 }
   7335                                 ios.width(25);
   7336                                 right(ios);
   7337                                 {
   7338                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7339                                     std::string ex(str, iter.base());
   7340                                     assert(ex == "*************+1.23457e+09");
   7341                                     assert(ios.width() == 0);
   7342                                 }
   7343                                 ios.width(25);
   7344                                 internal(ios);
   7345                                 {
   7346                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7347                                     std::string ex(str, iter.base());
   7348                                     assert(ex == "+*************1.23457e+09");
   7349                                     assert(ios.width() == 0);
   7350                                 }
   7351                             }
   7352                             ios.imbue(lg);
   7353                             {
   7354                                 ios.width(0);
   7355                                 {
   7356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7357                                     std::string ex(str, iter.base());
   7358                                     assert(ex == "+1;23457e+09");
   7359                                     assert(ios.width() == 0);
   7360                                 }
   7361                                 ios.width(25);
   7362                                 left(ios);
   7363                                 {
   7364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7365                                     std::string ex(str, iter.base());
   7366                                     assert(ex == "+1;23457e+09*************");
   7367                                     assert(ios.width() == 0);
   7368                                 }
   7369                                 ios.width(25);
   7370                                 right(ios);
   7371                                 {
   7372                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7373                                     std::string ex(str, iter.base());
   7374                                     assert(ex == "*************+1;23457e+09");
   7375                                     assert(ios.width() == 0);
   7376                                 }
   7377                                 ios.width(25);
   7378                                 internal(ios);
   7379                                 {
   7380                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7381                                     std::string ex(str, iter.base());
   7382                                     assert(ex == "+*************1;23457e+09");
   7383                                     assert(ios.width() == 0);
   7384                                 }
   7385                             }
   7386                         }
   7387                         showpoint(ios);
   7388                         {
   7389                             ios.imbue(lc);
   7390                             {
   7391                                 ios.width(0);
   7392                                 {
   7393                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7394                                     std::string ex(str, iter.base());
   7395                                     assert(ex == "+1.23457e+09");
   7396                                     assert(ios.width() == 0);
   7397                                 }
   7398                                 ios.width(25);
   7399                                 left(ios);
   7400                                 {
   7401                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7402                                     std::string ex(str, iter.base());
   7403                                     assert(ex == "+1.23457e+09*************");
   7404                                     assert(ios.width() == 0);
   7405                                 }
   7406                                 ios.width(25);
   7407                                 right(ios);
   7408                                 {
   7409                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7410                                     std::string ex(str, iter.base());
   7411                                     assert(ex == "*************+1.23457e+09");
   7412                                     assert(ios.width() == 0);
   7413                                 }
   7414                                 ios.width(25);
   7415                                 internal(ios);
   7416                                 {
   7417                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7418                                     std::string ex(str, iter.base());
   7419                                     assert(ex == "+*************1.23457e+09");
   7420                                     assert(ios.width() == 0);
   7421                                 }
   7422                             }
   7423                             ios.imbue(lg);
   7424                             {
   7425                                 ios.width(0);
   7426                                 {
   7427                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7428                                     std::string ex(str, iter.base());
   7429                                     assert(ex == "+1;23457e+09");
   7430                                     assert(ios.width() == 0);
   7431                                 }
   7432                                 ios.width(25);
   7433                                 left(ios);
   7434                                 {
   7435                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7436                                     std::string ex(str, iter.base());
   7437                                     assert(ex == "+1;23457e+09*************");
   7438                                     assert(ios.width() == 0);
   7439                                 }
   7440                                 ios.width(25);
   7441                                 right(ios);
   7442                                 {
   7443                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7444                                     std::string ex(str, iter.base());
   7445                                     assert(ex == "*************+1;23457e+09");
   7446                                     assert(ios.width() == 0);
   7447                                 }
   7448                                 ios.width(25);
   7449                                 internal(ios);
   7450                                 {
   7451                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7452                                     std::string ex(str, iter.base());
   7453                                     assert(ex == "+*************1;23457e+09");
   7454                                     assert(ios.width() == 0);
   7455                                 }
   7456                             }
   7457                         }
   7458                     }
   7459                 }
   7460                 uppercase(ios);
   7461                 {
   7462                     noshowpos(ios);
   7463                     {
   7464                         noshowpoint(ios);
   7465                         {
   7466                             ios.imbue(lc);
   7467                             {
   7468                                 ios.width(0);
   7469                                 {
   7470                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7471                                     std::string ex(str, iter.base());
   7472                                     assert(ex == "1.23457E+09");
   7473                                     assert(ios.width() == 0);
   7474                                 }
   7475                                 ios.width(25);
   7476                                 left(ios);
   7477                                 {
   7478                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7479                                     std::string ex(str, iter.base());
   7480                                     assert(ex == "1.23457E+09**************");
   7481                                     assert(ios.width() == 0);
   7482                                 }
   7483                                 ios.width(25);
   7484                                 right(ios);
   7485                                 {
   7486                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7487                                     std::string ex(str, iter.base());
   7488                                     assert(ex == "**************1.23457E+09");
   7489                                     assert(ios.width() == 0);
   7490                                 }
   7491                                 ios.width(25);
   7492                                 internal(ios);
   7493                                 {
   7494                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7495                                     std::string ex(str, iter.base());
   7496                                     assert(ex == "**************1.23457E+09");
   7497                                     assert(ios.width() == 0);
   7498                                 }
   7499                             }
   7500                             ios.imbue(lg);
   7501                             {
   7502                                 ios.width(0);
   7503                                 {
   7504                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7505                                     std::string ex(str, iter.base());
   7506                                     assert(ex == "1;23457E+09");
   7507                                     assert(ios.width() == 0);
   7508                                 }
   7509                                 ios.width(25);
   7510                                 left(ios);
   7511                                 {
   7512                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7513                                     std::string ex(str, iter.base());
   7514                                     assert(ex == "1;23457E+09**************");
   7515                                     assert(ios.width() == 0);
   7516                                 }
   7517                                 ios.width(25);
   7518                                 right(ios);
   7519                                 {
   7520                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7521                                     std::string ex(str, iter.base());
   7522                                     assert(ex == "**************1;23457E+09");
   7523                                     assert(ios.width() == 0);
   7524                                 }
   7525                                 ios.width(25);
   7526                                 internal(ios);
   7527                                 {
   7528                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7529                                     std::string ex(str, iter.base());
   7530                                     assert(ex == "**************1;23457E+09");
   7531                                     assert(ios.width() == 0);
   7532                                 }
   7533                             }
   7534                         }
   7535                         showpoint(ios);
   7536                         {
   7537                             ios.imbue(lc);
   7538                             {
   7539                                 ios.width(0);
   7540                                 {
   7541                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7542                                     std::string ex(str, iter.base());
   7543                                     assert(ex == "1.23457E+09");
   7544                                     assert(ios.width() == 0);
   7545                                 }
   7546                                 ios.width(25);
   7547                                 left(ios);
   7548                                 {
   7549                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7550                                     std::string ex(str, iter.base());
   7551                                     assert(ex == "1.23457E+09**************");
   7552                                     assert(ios.width() == 0);
   7553                                 }
   7554                                 ios.width(25);
   7555                                 right(ios);
   7556                                 {
   7557                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7558                                     std::string ex(str, iter.base());
   7559                                     assert(ex == "**************1.23457E+09");
   7560                                     assert(ios.width() == 0);
   7561                                 }
   7562                                 ios.width(25);
   7563                                 internal(ios);
   7564                                 {
   7565                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7566                                     std::string ex(str, iter.base());
   7567                                     assert(ex == "**************1.23457E+09");
   7568                                     assert(ios.width() == 0);
   7569                                 }
   7570                             }
   7571                             ios.imbue(lg);
   7572                             {
   7573                                 ios.width(0);
   7574                                 {
   7575                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7576                                     std::string ex(str, iter.base());
   7577                                     assert(ex == "1;23457E+09");
   7578                                     assert(ios.width() == 0);
   7579                                 }
   7580                                 ios.width(25);
   7581                                 left(ios);
   7582                                 {
   7583                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7584                                     std::string ex(str, iter.base());
   7585                                     assert(ex == "1;23457E+09**************");
   7586                                     assert(ios.width() == 0);
   7587                                 }
   7588                                 ios.width(25);
   7589                                 right(ios);
   7590                                 {
   7591                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7592                                     std::string ex(str, iter.base());
   7593                                     assert(ex == "**************1;23457E+09");
   7594                                     assert(ios.width() == 0);
   7595                                 }
   7596                                 ios.width(25);
   7597                                 internal(ios);
   7598                                 {
   7599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7600                                     std::string ex(str, iter.base());
   7601                                     assert(ex == "**************1;23457E+09");
   7602                                     assert(ios.width() == 0);
   7603                                 }
   7604                             }
   7605                         }
   7606                     }
   7607                     showpos(ios);
   7608                     {
   7609                         noshowpoint(ios);
   7610                         {
   7611                             ios.imbue(lc);
   7612                             {
   7613                                 ios.width(0);
   7614                                 {
   7615                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7616                                     std::string ex(str, iter.base());
   7617                                     assert(ex == "+1.23457E+09");
   7618                                     assert(ios.width() == 0);
   7619                                 }
   7620                                 ios.width(25);
   7621                                 left(ios);
   7622                                 {
   7623                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7624                                     std::string ex(str, iter.base());
   7625                                     assert(ex == "+1.23457E+09*************");
   7626                                     assert(ios.width() == 0);
   7627                                 }
   7628                                 ios.width(25);
   7629                                 right(ios);
   7630                                 {
   7631                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7632                                     std::string ex(str, iter.base());
   7633                                     assert(ex == "*************+1.23457E+09");
   7634                                     assert(ios.width() == 0);
   7635                                 }
   7636                                 ios.width(25);
   7637                                 internal(ios);
   7638                                 {
   7639                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7640                                     std::string ex(str, iter.base());
   7641                                     assert(ex == "+*************1.23457E+09");
   7642                                     assert(ios.width() == 0);
   7643                                 }
   7644                             }
   7645                             ios.imbue(lg);
   7646                             {
   7647                                 ios.width(0);
   7648                                 {
   7649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7650                                     std::string ex(str, iter.base());
   7651                                     assert(ex == "+1;23457E+09");
   7652                                     assert(ios.width() == 0);
   7653                                 }
   7654                                 ios.width(25);
   7655                                 left(ios);
   7656                                 {
   7657                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7658                                     std::string ex(str, iter.base());
   7659                                     assert(ex == "+1;23457E+09*************");
   7660                                     assert(ios.width() == 0);
   7661                                 }
   7662                                 ios.width(25);
   7663                                 right(ios);
   7664                                 {
   7665                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7666                                     std::string ex(str, iter.base());
   7667                                     assert(ex == "*************+1;23457E+09");
   7668                                     assert(ios.width() == 0);
   7669                                 }
   7670                                 ios.width(25);
   7671                                 internal(ios);
   7672                                 {
   7673                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7674                                     std::string ex(str, iter.base());
   7675                                     assert(ex == "+*************1;23457E+09");
   7676                                     assert(ios.width() == 0);
   7677                                 }
   7678                             }
   7679                         }
   7680                         showpoint(ios);
   7681                         {
   7682                             ios.imbue(lc);
   7683                             {
   7684                                 ios.width(0);
   7685                                 {
   7686                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7687                                     std::string ex(str, iter.base());
   7688                                     assert(ex == "+1.23457E+09");
   7689                                     assert(ios.width() == 0);
   7690                                 }
   7691                                 ios.width(25);
   7692                                 left(ios);
   7693                                 {
   7694                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7695                                     std::string ex(str, iter.base());
   7696                                     assert(ex == "+1.23457E+09*************");
   7697                                     assert(ios.width() == 0);
   7698                                 }
   7699                                 ios.width(25);
   7700                                 right(ios);
   7701                                 {
   7702                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7703                                     std::string ex(str, iter.base());
   7704                                     assert(ex == "*************+1.23457E+09");
   7705                                     assert(ios.width() == 0);
   7706                                 }
   7707                                 ios.width(25);
   7708                                 internal(ios);
   7709                                 {
   7710                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7711                                     std::string ex(str, iter.base());
   7712                                     assert(ex == "+*************1.23457E+09");
   7713                                     assert(ios.width() == 0);
   7714                                 }
   7715                             }
   7716                             ios.imbue(lg);
   7717                             {
   7718                                 ios.width(0);
   7719                                 {
   7720                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7721                                     std::string ex(str, iter.base());
   7722                                     assert(ex == "+1;23457E+09");
   7723                                     assert(ios.width() == 0);
   7724                                 }
   7725                                 ios.width(25);
   7726                                 left(ios);
   7727                                 {
   7728                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7729                                     std::string ex(str, iter.base());
   7730                                     assert(ex == "+1;23457E+09*************");
   7731                                     assert(ios.width() == 0);
   7732                                 }
   7733                                 ios.width(25);
   7734                                 right(ios);
   7735                                 {
   7736                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7737                                     std::string ex(str, iter.base());
   7738                                     assert(ex == "*************+1;23457E+09");
   7739                                     assert(ios.width() == 0);
   7740                                 }
   7741                                 ios.width(25);
   7742                                 internal(ios);
   7743                                 {
   7744                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7745                                     std::string ex(str, iter.base());
   7746                                     assert(ex == "+*************1;23457E+09");
   7747                                     assert(ios.width() == 0);
   7748                                 }
   7749                             }
   7750                         }
   7751                     }
   7752                 }
   7753             }
   7754             ios.precision(16);
   7755             {
   7756                 nouppercase(ios);
   7757                 {
   7758                     noshowpos(ios);
   7759                     {
   7760                         noshowpoint(ios);
   7761                         {
   7762                             ios.imbue(lc);
   7763                             {
   7764                                 ios.width(0);
   7765                                 {
   7766                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7767                                     std::string ex(str, iter.base());
   7768                                     assert(ex == "1234567890.125");
   7769                                     assert(ios.width() == 0);
   7770                                 }
   7771                                 ios.width(25);
   7772                                 left(ios);
   7773                                 {
   7774                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7775                                     std::string ex(str, iter.base());
   7776                                     assert(ex == "1234567890.125***********");
   7777                                     assert(ios.width() == 0);
   7778                                 }
   7779                                 ios.width(25);
   7780                                 right(ios);
   7781                                 {
   7782                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7783                                     std::string ex(str, iter.base());
   7784                                     assert(ex == "***********1234567890.125");
   7785                                     assert(ios.width() == 0);
   7786                                 }
   7787                                 ios.width(25);
   7788                                 internal(ios);
   7789                                 {
   7790                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7791                                     std::string ex(str, iter.base());
   7792                                     assert(ex == "***********1234567890.125");
   7793                                     assert(ios.width() == 0);
   7794                                 }
   7795                             }
   7796                             ios.imbue(lg);
   7797                             {
   7798                                 ios.width(0);
   7799                                 {
   7800                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7801                                     std::string ex(str, iter.base());
   7802                                     assert(ex == "1_234_567_89_0;125");
   7803                                     assert(ios.width() == 0);
   7804                                 }
   7805                                 ios.width(25);
   7806                                 left(ios);
   7807                                 {
   7808                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7809                                     std::string ex(str, iter.base());
   7810                                     assert(ex == "1_234_567_89_0;125*******");
   7811                                     assert(ios.width() == 0);
   7812                                 }
   7813                                 ios.width(25);
   7814                                 right(ios);
   7815                                 {
   7816                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7817                                     std::string ex(str, iter.base());
   7818                                     assert(ex == "*******1_234_567_89_0;125");
   7819                                     assert(ios.width() == 0);
   7820                                 }
   7821                                 ios.width(25);
   7822                                 internal(ios);
   7823                                 {
   7824                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7825                                     std::string ex(str, iter.base());
   7826                                     assert(ex == "*******1_234_567_89_0;125");
   7827                                     assert(ios.width() == 0);
   7828                                 }
   7829                             }
   7830                         }
   7831                         showpoint(ios);
   7832                         {
   7833                             ios.imbue(lc);
   7834                             {
   7835                                 ios.width(0);
   7836                                 {
   7837                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7838                                     std::string ex(str, iter.base());
   7839                                     assert(ex == "1234567890.125000");
   7840                                     assert(ios.width() == 0);
   7841                                 }
   7842                                 ios.width(25);
   7843                                 left(ios);
   7844                                 {
   7845                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7846                                     std::string ex(str, iter.base());
   7847                                     assert(ex == "1234567890.125000********");
   7848                                     assert(ios.width() == 0);
   7849                                 }
   7850                                 ios.width(25);
   7851                                 right(ios);
   7852                                 {
   7853                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7854                                     std::string ex(str, iter.base());
   7855                                     assert(ex == "********1234567890.125000");
   7856                                     assert(ios.width() == 0);
   7857                                 }
   7858                                 ios.width(25);
   7859                                 internal(ios);
   7860                                 {
   7861                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7862                                     std::string ex(str, iter.base());
   7863                                     assert(ex == "********1234567890.125000");
   7864                                     assert(ios.width() == 0);
   7865                                 }
   7866                             }
   7867                             ios.imbue(lg);
   7868                             {
   7869                                 ios.width(0);
   7870                                 {
   7871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7872                                     std::string ex(str, iter.base());
   7873                                     assert(ex == "1_234_567_89_0;125000");
   7874                                     assert(ios.width() == 0);
   7875                                 }
   7876                                 ios.width(25);
   7877                                 left(ios);
   7878                                 {
   7879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7880                                     std::string ex(str, iter.base());
   7881                                     assert(ex == "1_234_567_89_0;125000****");
   7882                                     assert(ios.width() == 0);
   7883                                 }
   7884                                 ios.width(25);
   7885                                 right(ios);
   7886                                 {
   7887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7888                                     std::string ex(str, iter.base());
   7889                                     assert(ex == "****1_234_567_89_0;125000");
   7890                                     assert(ios.width() == 0);
   7891                                 }
   7892                                 ios.width(25);
   7893                                 internal(ios);
   7894                                 {
   7895                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7896                                     std::string ex(str, iter.base());
   7897                                     assert(ex == "****1_234_567_89_0;125000");
   7898                                     assert(ios.width() == 0);
   7899                                 }
   7900                             }
   7901                         }
   7902                     }
   7903                     showpos(ios);
   7904                     {
   7905                         noshowpoint(ios);
   7906                         {
   7907                             ios.imbue(lc);
   7908                             {
   7909                                 ios.width(0);
   7910                                 {
   7911                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7912                                     std::string ex(str, iter.base());
   7913                                     assert(ex == "+1234567890.125");
   7914                                     assert(ios.width() == 0);
   7915                                 }
   7916                                 ios.width(25);
   7917                                 left(ios);
   7918                                 {
   7919                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7920                                     std::string ex(str, iter.base());
   7921                                     assert(ex == "+1234567890.125**********");
   7922                                     assert(ios.width() == 0);
   7923                                 }
   7924                                 ios.width(25);
   7925                                 right(ios);
   7926                                 {
   7927                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7928                                     std::string ex(str, iter.base());
   7929                                     assert(ex == "**********+1234567890.125");
   7930                                     assert(ios.width() == 0);
   7931                                 }
   7932                                 ios.width(25);
   7933                                 internal(ios);
   7934                                 {
   7935                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7936                                     std::string ex(str, iter.base());
   7937                                     assert(ex == "+**********1234567890.125");
   7938                                     assert(ios.width() == 0);
   7939                                 }
   7940                             }
   7941                             ios.imbue(lg);
   7942                             {
   7943                                 ios.width(0);
   7944                                 {
   7945                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7946                                     std::string ex(str, iter.base());
   7947                                     assert(ex == "+1_234_567_89_0;125");
   7948                                     assert(ios.width() == 0);
   7949                                 }
   7950                                 ios.width(25);
   7951                                 left(ios);
   7952                                 {
   7953                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7954                                     std::string ex(str, iter.base());
   7955                                     assert(ex == "+1_234_567_89_0;125******");
   7956                                     assert(ios.width() == 0);
   7957                                 }
   7958                                 ios.width(25);
   7959                                 right(ios);
   7960                                 {
   7961                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7962                                     std::string ex(str, iter.base());
   7963                                     assert(ex == "******+1_234_567_89_0;125");
   7964                                     assert(ios.width() == 0);
   7965                                 }
   7966                                 ios.width(25);
   7967                                 internal(ios);
   7968                                 {
   7969                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7970                                     std::string ex(str, iter.base());
   7971                                     assert(ex == "+******1_234_567_89_0;125");
   7972                                     assert(ios.width() == 0);
   7973                                 }
   7974                             }
   7975                         }
   7976                         showpoint(ios);
   7977                         {
   7978                             ios.imbue(lc);
   7979                             {
   7980                                 ios.width(0);
   7981                                 {
   7982                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7983                                     std::string ex(str, iter.base());
   7984                                     assert(ex == "+1234567890.125000");
   7985                                     assert(ios.width() == 0);
   7986                                 }
   7987                                 ios.width(25);
   7988                                 left(ios);
   7989                                 {
   7990                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7991                                     std::string ex(str, iter.base());
   7992                                     assert(ex == "+1234567890.125000*******");
   7993                                     assert(ios.width() == 0);
   7994                                 }
   7995                                 ios.width(25);
   7996                                 right(ios);
   7997                                 {
   7998                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   7999                                     std::string ex(str, iter.base());
   8000                                     assert(ex == "*******+1234567890.125000");
   8001                                     assert(ios.width() == 0);
   8002                                 }
   8003                                 ios.width(25);
   8004                                 internal(ios);
   8005                                 {
   8006                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8007                                     std::string ex(str, iter.base());
   8008                                     assert(ex == "+*******1234567890.125000");
   8009                                     assert(ios.width() == 0);
   8010                                 }
   8011                             }
   8012                             ios.imbue(lg);
   8013                             {
   8014                                 ios.width(0);
   8015                                 {
   8016                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8017                                     std::string ex(str, iter.base());
   8018                                     assert(ex == "+1_234_567_89_0;125000");
   8019                                     assert(ios.width() == 0);
   8020                                 }
   8021                                 ios.width(25);
   8022                                 left(ios);
   8023                                 {
   8024                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8025                                     std::string ex(str, iter.base());
   8026                                     assert(ex == "+1_234_567_89_0;125000***");
   8027                                     assert(ios.width() == 0);
   8028                                 }
   8029                                 ios.width(25);
   8030                                 right(ios);
   8031                                 {
   8032                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8033                                     std::string ex(str, iter.base());
   8034                                     assert(ex == "***+1_234_567_89_0;125000");
   8035                                     assert(ios.width() == 0);
   8036                                 }
   8037                                 ios.width(25);
   8038                                 internal(ios);
   8039                                 {
   8040                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8041                                     std::string ex(str, iter.base());
   8042                                     assert(ex == "+***1_234_567_89_0;125000");
   8043                                     assert(ios.width() == 0);
   8044                                 }
   8045                             }
   8046                         }
   8047                     }
   8048                 }
   8049                 uppercase(ios);
   8050                 {
   8051                     noshowpos(ios);
   8052                     {
   8053                         noshowpoint(ios);
   8054                         {
   8055                             ios.imbue(lc);
   8056                             {
   8057                                 ios.width(0);
   8058                                 {
   8059                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8060                                     std::string ex(str, iter.base());
   8061                                     assert(ex == "1234567890.125");
   8062                                     assert(ios.width() == 0);
   8063                                 }
   8064                                 ios.width(25);
   8065                                 left(ios);
   8066                                 {
   8067                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8068                                     std::string ex(str, iter.base());
   8069                                     assert(ex == "1234567890.125***********");
   8070                                     assert(ios.width() == 0);
   8071                                 }
   8072                                 ios.width(25);
   8073                                 right(ios);
   8074                                 {
   8075                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8076                                     std::string ex(str, iter.base());
   8077                                     assert(ex == "***********1234567890.125");
   8078                                     assert(ios.width() == 0);
   8079                                 }
   8080                                 ios.width(25);
   8081                                 internal(ios);
   8082                                 {
   8083                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8084                                     std::string ex(str, iter.base());
   8085                                     assert(ex == "***********1234567890.125");
   8086                                     assert(ios.width() == 0);
   8087                                 }
   8088                             }
   8089                             ios.imbue(lg);
   8090                             {
   8091                                 ios.width(0);
   8092                                 {
   8093                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8094                                     std::string ex(str, iter.base());
   8095                                     assert(ex == "1_234_567_89_0;125");
   8096                                     assert(ios.width() == 0);
   8097                                 }
   8098                                 ios.width(25);
   8099                                 left(ios);
   8100                                 {
   8101                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8102                                     std::string ex(str, iter.base());
   8103                                     assert(ex == "1_234_567_89_0;125*******");
   8104                                     assert(ios.width() == 0);
   8105                                 }
   8106                                 ios.width(25);
   8107                                 right(ios);
   8108                                 {
   8109                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8110                                     std::string ex(str, iter.base());
   8111                                     assert(ex == "*******1_234_567_89_0;125");
   8112                                     assert(ios.width() == 0);
   8113                                 }
   8114                                 ios.width(25);
   8115                                 internal(ios);
   8116                                 {
   8117                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8118                                     std::string ex(str, iter.base());
   8119                                     assert(ex == "*******1_234_567_89_0;125");
   8120                                     assert(ios.width() == 0);
   8121                                 }
   8122                             }
   8123                         }
   8124                         showpoint(ios);
   8125                         {
   8126                             ios.imbue(lc);
   8127                             {
   8128                                 ios.width(0);
   8129                                 {
   8130                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8131                                     std::string ex(str, iter.base());
   8132                                     assert(ex == "1234567890.125000");
   8133                                     assert(ios.width() == 0);
   8134                                 }
   8135                                 ios.width(25);
   8136                                 left(ios);
   8137                                 {
   8138                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8139                                     std::string ex(str, iter.base());
   8140                                     assert(ex == "1234567890.125000********");
   8141                                     assert(ios.width() == 0);
   8142                                 }
   8143                                 ios.width(25);
   8144                                 right(ios);
   8145                                 {
   8146                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8147                                     std::string ex(str, iter.base());
   8148                                     assert(ex == "********1234567890.125000");
   8149                                     assert(ios.width() == 0);
   8150                                 }
   8151                                 ios.width(25);
   8152                                 internal(ios);
   8153                                 {
   8154                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8155                                     std::string ex(str, iter.base());
   8156                                     assert(ex == "********1234567890.125000");
   8157                                     assert(ios.width() == 0);
   8158                                 }
   8159                             }
   8160                             ios.imbue(lg);
   8161                             {
   8162                                 ios.width(0);
   8163                                 {
   8164                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8165                                     std::string ex(str, iter.base());
   8166                                     assert(ex == "1_234_567_89_0;125000");
   8167                                     assert(ios.width() == 0);
   8168                                 }
   8169                                 ios.width(25);
   8170                                 left(ios);
   8171                                 {
   8172                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8173                                     std::string ex(str, iter.base());
   8174                                     assert(ex == "1_234_567_89_0;125000****");
   8175                                     assert(ios.width() == 0);
   8176                                 }
   8177                                 ios.width(25);
   8178                                 right(ios);
   8179                                 {
   8180                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8181                                     std::string ex(str, iter.base());
   8182                                     assert(ex == "****1_234_567_89_0;125000");
   8183                                     assert(ios.width() == 0);
   8184                                 }
   8185                                 ios.width(25);
   8186                                 internal(ios);
   8187                                 {
   8188                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8189                                     std::string ex(str, iter.base());
   8190                                     assert(ex == "****1_234_567_89_0;125000");
   8191                                     assert(ios.width() == 0);
   8192                                 }
   8193                             }
   8194                         }
   8195                     }
   8196                     showpos(ios);
   8197                     {
   8198                         noshowpoint(ios);
   8199                         {
   8200                             ios.imbue(lc);
   8201                             {
   8202                                 ios.width(0);
   8203                                 {
   8204                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8205                                     std::string ex(str, iter.base());
   8206                                     assert(ex == "+1234567890.125");
   8207                                     assert(ios.width() == 0);
   8208                                 }
   8209                                 ios.width(25);
   8210                                 left(ios);
   8211                                 {
   8212                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8213                                     std::string ex(str, iter.base());
   8214                                     assert(ex == "+1234567890.125**********");
   8215                                     assert(ios.width() == 0);
   8216                                 }
   8217                                 ios.width(25);
   8218                                 right(ios);
   8219                                 {
   8220                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8221                                     std::string ex(str, iter.base());
   8222                                     assert(ex == "**********+1234567890.125");
   8223                                     assert(ios.width() == 0);
   8224                                 }
   8225                                 ios.width(25);
   8226                                 internal(ios);
   8227                                 {
   8228                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8229                                     std::string ex(str, iter.base());
   8230                                     assert(ex == "+**********1234567890.125");
   8231                                     assert(ios.width() == 0);
   8232                                 }
   8233                             }
   8234                             ios.imbue(lg);
   8235                             {
   8236                                 ios.width(0);
   8237                                 {
   8238                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8239                                     std::string ex(str, iter.base());
   8240                                     assert(ex == "+1_234_567_89_0;125");
   8241                                     assert(ios.width() == 0);
   8242                                 }
   8243                                 ios.width(25);
   8244                                 left(ios);
   8245                                 {
   8246                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8247                                     std::string ex(str, iter.base());
   8248                                     assert(ex == "+1_234_567_89_0;125******");
   8249                                     assert(ios.width() == 0);
   8250                                 }
   8251                                 ios.width(25);
   8252                                 right(ios);
   8253                                 {
   8254                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8255                                     std::string ex(str, iter.base());
   8256                                     assert(ex == "******+1_234_567_89_0;125");
   8257                                     assert(ios.width() == 0);
   8258                                 }
   8259                                 ios.width(25);
   8260                                 internal(ios);
   8261                                 {
   8262                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8263                                     std::string ex(str, iter.base());
   8264                                     assert(ex == "+******1_234_567_89_0;125");
   8265                                     assert(ios.width() == 0);
   8266                                 }
   8267                             }
   8268                         }
   8269                         showpoint(ios);
   8270                         {
   8271                             ios.imbue(lc);
   8272                             {
   8273                                 ios.width(0);
   8274                                 {
   8275                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8276                                     std::string ex(str, iter.base());
   8277                                     assert(ex == "+1234567890.125000");
   8278                                     assert(ios.width() == 0);
   8279                                 }
   8280                                 ios.width(25);
   8281                                 left(ios);
   8282                                 {
   8283                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8284                                     std::string ex(str, iter.base());
   8285                                     assert(ex == "+1234567890.125000*******");
   8286                                     assert(ios.width() == 0);
   8287                                 }
   8288                                 ios.width(25);
   8289                                 right(ios);
   8290                                 {
   8291                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8292                                     std::string ex(str, iter.base());
   8293                                     assert(ex == "*******+1234567890.125000");
   8294                                     assert(ios.width() == 0);
   8295                                 }
   8296                                 ios.width(25);
   8297                                 internal(ios);
   8298                                 {
   8299                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8300                                     std::string ex(str, iter.base());
   8301                                     assert(ex == "+*******1234567890.125000");
   8302                                     assert(ios.width() == 0);
   8303                                 }
   8304                             }
   8305                             ios.imbue(lg);
   8306                             {
   8307                                 ios.width(0);
   8308                                 {
   8309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8310                                     std::string ex(str, iter.base());
   8311                                     assert(ex == "+1_234_567_89_0;125000");
   8312                                     assert(ios.width() == 0);
   8313                                 }
   8314                                 ios.width(25);
   8315                                 left(ios);
   8316                                 {
   8317                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8318                                     std::string ex(str, iter.base());
   8319                                     assert(ex == "+1_234_567_89_0;125000***");
   8320                                     assert(ios.width() == 0);
   8321                                 }
   8322                                 ios.width(25);
   8323                                 right(ios);
   8324                                 {
   8325                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8326                                     std::string ex(str, iter.base());
   8327                                     assert(ex == "***+1_234_567_89_0;125000");
   8328                                     assert(ios.width() == 0);
   8329                                 }
   8330                                 ios.width(25);
   8331                                 internal(ios);
   8332                                 {
   8333                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8334                                     std::string ex(str, iter.base());
   8335                                     assert(ex == "+***1_234_567_89_0;125000");
   8336                                     assert(ios.width() == 0);
   8337                                 }
   8338                             }
   8339                         }
   8340                     }
   8341                 }
   8342             }
   8343             ios.precision(60);
   8344             {
   8345                 nouppercase(ios);
   8346                 {
   8347                     noshowpos(ios);
   8348                     {
   8349                         noshowpoint(ios);
   8350                         {
   8351                             ios.imbue(lc);
   8352                             {
   8353                                 ios.width(0);
   8354                                 {
   8355                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8356                                     std::string ex(str, iter.base());
   8357                                     assert(ex == "1234567890.125");
   8358                                     assert(ios.width() == 0);
   8359                                 }
   8360                                 ios.width(25);
   8361                                 left(ios);
   8362                                 {
   8363                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8364                                     std::string ex(str, iter.base());
   8365                                     assert(ex == "1234567890.125***********");
   8366                                     assert(ios.width() == 0);
   8367                                 }
   8368                                 ios.width(25);
   8369                                 right(ios);
   8370                                 {
   8371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8372                                     std::string ex(str, iter.base());
   8373                                     assert(ex == "***********1234567890.125");
   8374                                     assert(ios.width() == 0);
   8375                                 }
   8376                                 ios.width(25);
   8377                                 internal(ios);
   8378                                 {
   8379                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8380                                     std::string ex(str, iter.base());
   8381                                     assert(ex == "***********1234567890.125");
   8382                                     assert(ios.width() == 0);
   8383                                 }
   8384                             }
   8385                             ios.imbue(lg);
   8386                             {
   8387                                 ios.width(0);
   8388                                 {
   8389                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8390                                     std::string ex(str, iter.base());
   8391                                     assert(ex == "1_234_567_89_0;125");
   8392                                     assert(ios.width() == 0);
   8393                                 }
   8394                                 ios.width(25);
   8395                                 left(ios);
   8396                                 {
   8397                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8398                                     std::string ex(str, iter.base());
   8399                                     assert(ex == "1_234_567_89_0;125*******");
   8400                                     assert(ios.width() == 0);
   8401                                 }
   8402                                 ios.width(25);
   8403                                 right(ios);
   8404                                 {
   8405                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8406                                     std::string ex(str, iter.base());
   8407                                     assert(ex == "*******1_234_567_89_0;125");
   8408                                     assert(ios.width() == 0);
   8409                                 }
   8410                                 ios.width(25);
   8411                                 internal(ios);
   8412                                 {
   8413                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8414                                     std::string ex(str, iter.base());
   8415                                     assert(ex == "*******1_234_567_89_0;125");
   8416                                     assert(ios.width() == 0);
   8417                                 }
   8418                             }
   8419                         }
   8420                         showpoint(ios);
   8421                         {
   8422                             ios.imbue(lc);
   8423                             {
   8424                                 ios.width(0);
   8425                                 {
   8426                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8427                                     std::string ex(str, iter.base());
   8428                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8429                                     assert(ios.width() == 0);
   8430                                 }
   8431                                 ios.width(25);
   8432                                 left(ios);
   8433                                 {
   8434                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8435                                     std::string ex(str, iter.base());
   8436                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8437                                     assert(ios.width() == 0);
   8438                                 }
   8439                                 ios.width(25);
   8440                                 right(ios);
   8441                                 {
   8442                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8443                                     std::string ex(str, iter.base());
   8444                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8445                                     assert(ios.width() == 0);
   8446                                 }
   8447                                 ios.width(25);
   8448                                 internal(ios);
   8449                                 {
   8450                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8451                                     std::string ex(str, iter.base());
   8452                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8453                                     assert(ios.width() == 0);
   8454                                 }
   8455                             }
   8456                             ios.imbue(lg);
   8457                             {
   8458                                 ios.width(0);
   8459                                 {
   8460                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8461                                     std::string ex(str, iter.base());
   8462                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8463                                     assert(ios.width() == 0);
   8464                                 }
   8465                                 ios.width(25);
   8466                                 left(ios);
   8467                                 {
   8468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8469                                     std::string ex(str, iter.base());
   8470                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8471                                     assert(ios.width() == 0);
   8472                                 }
   8473                                 ios.width(25);
   8474                                 right(ios);
   8475                                 {
   8476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8477                                     std::string ex(str, iter.base());
   8478                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8479                                     assert(ios.width() == 0);
   8480                                 }
   8481                                 ios.width(25);
   8482                                 internal(ios);
   8483                                 {
   8484                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8485                                     std::string ex(str, iter.base());
   8486                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8487                                     assert(ios.width() == 0);
   8488                                 }
   8489                             }
   8490                         }
   8491                     }
   8492                     showpos(ios);
   8493                     {
   8494                         noshowpoint(ios);
   8495                         {
   8496                             ios.imbue(lc);
   8497                             {
   8498                                 ios.width(0);
   8499                                 {
   8500                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8501                                     std::string ex(str, iter.base());
   8502                                     assert(ex == "+1234567890.125");
   8503                                     assert(ios.width() == 0);
   8504                                 }
   8505                                 ios.width(25);
   8506                                 left(ios);
   8507                                 {
   8508                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8509                                     std::string ex(str, iter.base());
   8510                                     assert(ex == "+1234567890.125**********");
   8511                                     assert(ios.width() == 0);
   8512                                 }
   8513                                 ios.width(25);
   8514                                 right(ios);
   8515                                 {
   8516                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8517                                     std::string ex(str, iter.base());
   8518                                     assert(ex == "**********+1234567890.125");
   8519                                     assert(ios.width() == 0);
   8520                                 }
   8521                                 ios.width(25);
   8522                                 internal(ios);
   8523                                 {
   8524                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8525                                     std::string ex(str, iter.base());
   8526                                     assert(ex == "+**********1234567890.125");
   8527                                     assert(ios.width() == 0);
   8528                                 }
   8529                             }
   8530                             ios.imbue(lg);
   8531                             {
   8532                                 ios.width(0);
   8533                                 {
   8534                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8535                                     std::string ex(str, iter.base());
   8536                                     assert(ex == "+1_234_567_89_0;125");
   8537                                     assert(ios.width() == 0);
   8538                                 }
   8539                                 ios.width(25);
   8540                                 left(ios);
   8541                                 {
   8542                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8543                                     std::string ex(str, iter.base());
   8544                                     assert(ex == "+1_234_567_89_0;125******");
   8545                                     assert(ios.width() == 0);
   8546                                 }
   8547                                 ios.width(25);
   8548                                 right(ios);
   8549                                 {
   8550                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8551                                     std::string ex(str, iter.base());
   8552                                     assert(ex == "******+1_234_567_89_0;125");
   8553                                     assert(ios.width() == 0);
   8554                                 }
   8555                                 ios.width(25);
   8556                                 internal(ios);
   8557                                 {
   8558                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8559                                     std::string ex(str, iter.base());
   8560                                     assert(ex == "+******1_234_567_89_0;125");
   8561                                     assert(ios.width() == 0);
   8562                                 }
   8563                             }
   8564                         }
   8565                         showpoint(ios);
   8566                         {
   8567                             ios.imbue(lc);
   8568                             {
   8569                                 ios.width(0);
   8570                                 {
   8571                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8572                                     std::string ex(str, iter.base());
   8573                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8574                                     assert(ios.width() == 0);
   8575                                 }
   8576                                 ios.width(25);
   8577                                 left(ios);
   8578                                 {
   8579                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8580                                     std::string ex(str, iter.base());
   8581                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8582                                     assert(ios.width() == 0);
   8583                                 }
   8584                                 ios.width(25);
   8585                                 right(ios);
   8586                                 {
   8587                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8588                                     std::string ex(str, iter.base());
   8589                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8590                                     assert(ios.width() == 0);
   8591                                 }
   8592                                 ios.width(25);
   8593                                 internal(ios);
   8594                                 {
   8595                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8596                                     std::string ex(str, iter.base());
   8597                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8598                                     assert(ios.width() == 0);
   8599                                 }
   8600                             }
   8601                             ios.imbue(lg);
   8602                             {
   8603                                 ios.width(0);
   8604                                 {
   8605                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8606                                     std::string ex(str, iter.base());
   8607                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8608                                     assert(ios.width() == 0);
   8609                                 }
   8610                                 ios.width(25);
   8611                                 left(ios);
   8612                                 {
   8613                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8614                                     std::string ex(str, iter.base());
   8615                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8616                                     assert(ios.width() == 0);
   8617                                 }
   8618                                 ios.width(25);
   8619                                 right(ios);
   8620                                 {
   8621                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8622                                     std::string ex(str, iter.base());
   8623                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8624                                     assert(ios.width() == 0);
   8625                                 }
   8626                                 ios.width(25);
   8627                                 internal(ios);
   8628                                 {
   8629                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8630                                     std::string ex(str, iter.base());
   8631                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8632                                     assert(ios.width() == 0);
   8633                                 }
   8634                             }
   8635                         }
   8636                     }
   8637                 }
   8638                 uppercase(ios);
   8639                 {
   8640                     noshowpos(ios);
   8641                     {
   8642                         noshowpoint(ios);
   8643                         {
   8644                             ios.imbue(lc);
   8645                             {
   8646                                 ios.width(0);
   8647                                 {
   8648                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8649                                     std::string ex(str, iter.base());
   8650                                     assert(ex == "1234567890.125");
   8651                                     assert(ios.width() == 0);
   8652                                 }
   8653                                 ios.width(25);
   8654                                 left(ios);
   8655                                 {
   8656                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8657                                     std::string ex(str, iter.base());
   8658                                     assert(ex == "1234567890.125***********");
   8659                                     assert(ios.width() == 0);
   8660                                 }
   8661                                 ios.width(25);
   8662                                 right(ios);
   8663                                 {
   8664                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8665                                     std::string ex(str, iter.base());
   8666                                     assert(ex == "***********1234567890.125");
   8667                                     assert(ios.width() == 0);
   8668                                 }
   8669                                 ios.width(25);
   8670                                 internal(ios);
   8671                                 {
   8672                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8673                                     std::string ex(str, iter.base());
   8674                                     assert(ex == "***********1234567890.125");
   8675                                     assert(ios.width() == 0);
   8676                                 }
   8677                             }
   8678                             ios.imbue(lg);
   8679                             {
   8680                                 ios.width(0);
   8681                                 {
   8682                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8683                                     std::string ex(str, iter.base());
   8684                                     assert(ex == "1_234_567_89_0;125");
   8685                                     assert(ios.width() == 0);
   8686                                 }
   8687                                 ios.width(25);
   8688                                 left(ios);
   8689                                 {
   8690                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8691                                     std::string ex(str, iter.base());
   8692                                     assert(ex == "1_234_567_89_0;125*******");
   8693                                     assert(ios.width() == 0);
   8694                                 }
   8695                                 ios.width(25);
   8696                                 right(ios);
   8697                                 {
   8698                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8699                                     std::string ex(str, iter.base());
   8700                                     assert(ex == "*******1_234_567_89_0;125");
   8701                                     assert(ios.width() == 0);
   8702                                 }
   8703                                 ios.width(25);
   8704                                 internal(ios);
   8705                                 {
   8706                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8707                                     std::string ex(str, iter.base());
   8708                                     assert(ex == "*******1_234_567_89_0;125");
   8709                                     assert(ios.width() == 0);
   8710                                 }
   8711                             }
   8712                         }
   8713                         showpoint(ios);
   8714                         {
   8715                             ios.imbue(lc);
   8716                             {
   8717                                 ios.width(0);
   8718                                 {
   8719                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8720                                     std::string ex(str, iter.base());
   8721                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8722                                     assert(ios.width() == 0);
   8723                                 }
   8724                                 ios.width(25);
   8725                                 left(ios);
   8726                                 {
   8727                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8728                                     std::string ex(str, iter.base());
   8729                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8730                                     assert(ios.width() == 0);
   8731                                 }
   8732                                 ios.width(25);
   8733                                 right(ios);
   8734                                 {
   8735                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8736                                     std::string ex(str, iter.base());
   8737                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8738                                     assert(ios.width() == 0);
   8739                                 }
   8740                                 ios.width(25);
   8741                                 internal(ios);
   8742                                 {
   8743                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8744                                     std::string ex(str, iter.base());
   8745                                     assert(ex == "1234567890.12500000000000000000000000000000000000000000000000");
   8746                                     assert(ios.width() == 0);
   8747                                 }
   8748                             }
   8749                             ios.imbue(lg);
   8750                             {
   8751                                 ios.width(0);
   8752                                 {
   8753                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8754                                     std::string ex(str, iter.base());
   8755                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8756                                     assert(ios.width() == 0);
   8757                                 }
   8758                                 ios.width(25);
   8759                                 left(ios);
   8760                                 {
   8761                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8762                                     std::string ex(str, iter.base());
   8763                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8764                                     assert(ios.width() == 0);
   8765                                 }
   8766                                 ios.width(25);
   8767                                 right(ios);
   8768                                 {
   8769                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8770                                     std::string ex(str, iter.base());
   8771                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8772                                     assert(ios.width() == 0);
   8773                                 }
   8774                                 ios.width(25);
   8775                                 internal(ios);
   8776                                 {
   8777                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8778                                     std::string ex(str, iter.base());
   8779                                     assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8780                                     assert(ios.width() == 0);
   8781                                 }
   8782                             }
   8783                         }
   8784                     }
   8785                     showpos(ios);
   8786                     {
   8787                         noshowpoint(ios);
   8788                         {
   8789                             ios.imbue(lc);
   8790                             {
   8791                                 ios.width(0);
   8792                                 {
   8793                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8794                                     std::string ex(str, iter.base());
   8795                                     assert(ex == "+1234567890.125");
   8796                                     assert(ios.width() == 0);
   8797                                 }
   8798                                 ios.width(25);
   8799                                 left(ios);
   8800                                 {
   8801                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8802                                     std::string ex(str, iter.base());
   8803                                     assert(ex == "+1234567890.125**********");
   8804                                     assert(ios.width() == 0);
   8805                                 }
   8806                                 ios.width(25);
   8807                                 right(ios);
   8808                                 {
   8809                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8810                                     std::string ex(str, iter.base());
   8811                                     assert(ex == "**********+1234567890.125");
   8812                                     assert(ios.width() == 0);
   8813                                 }
   8814                                 ios.width(25);
   8815                                 internal(ios);
   8816                                 {
   8817                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8818                                     std::string ex(str, iter.base());
   8819                                     assert(ex == "+**********1234567890.125");
   8820                                     assert(ios.width() == 0);
   8821                                 }
   8822                             }
   8823                             ios.imbue(lg);
   8824                             {
   8825                                 ios.width(0);
   8826                                 {
   8827                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8828                                     std::string ex(str, iter.base());
   8829                                     assert(ex == "+1_234_567_89_0;125");
   8830                                     assert(ios.width() == 0);
   8831                                 }
   8832                                 ios.width(25);
   8833                                 left(ios);
   8834                                 {
   8835                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8836                                     std::string ex(str, iter.base());
   8837                                     assert(ex == "+1_234_567_89_0;125******");
   8838                                     assert(ios.width() == 0);
   8839                                 }
   8840                                 ios.width(25);
   8841                                 right(ios);
   8842                                 {
   8843                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8844                                     std::string ex(str, iter.base());
   8845                                     assert(ex == "******+1_234_567_89_0;125");
   8846                                     assert(ios.width() == 0);
   8847                                 }
   8848                                 ios.width(25);
   8849                                 internal(ios);
   8850                                 {
   8851                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8852                                     std::string ex(str, iter.base());
   8853                                     assert(ex == "+******1_234_567_89_0;125");
   8854                                     assert(ios.width() == 0);
   8855                                 }
   8856                             }
   8857                         }
   8858                         showpoint(ios);
   8859                         {
   8860                             ios.imbue(lc);
   8861                             {
   8862                                 ios.width(0);
   8863                                 {
   8864                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8865                                     std::string ex(str, iter.base());
   8866                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8867                                     assert(ios.width() == 0);
   8868                                 }
   8869                                 ios.width(25);
   8870                                 left(ios);
   8871                                 {
   8872                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8873                                     std::string ex(str, iter.base());
   8874                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8875                                     assert(ios.width() == 0);
   8876                                 }
   8877                                 ios.width(25);
   8878                                 right(ios);
   8879                                 {
   8880                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8881                                     std::string ex(str, iter.base());
   8882                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8883                                     assert(ios.width() == 0);
   8884                                 }
   8885                                 ios.width(25);
   8886                                 internal(ios);
   8887                                 {
   8888                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8889                                     std::string ex(str, iter.base());
   8890                                     assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000");
   8891                                     assert(ios.width() == 0);
   8892                                 }
   8893                             }
   8894                             ios.imbue(lg);
   8895                             {
   8896                                 ios.width(0);
   8897                                 {
   8898                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8899                                     std::string ex(str, iter.base());
   8900                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8901                                     assert(ios.width() == 0);
   8902                                 }
   8903                                 ios.width(25);
   8904                                 left(ios);
   8905                                 {
   8906                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8907                                     std::string ex(str, iter.base());
   8908                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8909                                     assert(ios.width() == 0);
   8910                                 }
   8911                                 ios.width(25);
   8912                                 right(ios);
   8913                                 {
   8914                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8915                                     std::string ex(str, iter.base());
   8916                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8917                                     assert(ios.width() == 0);
   8918                                 }
   8919                                 ios.width(25);
   8920                                 internal(ios);
   8921                                 {
   8922                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8923                                     std::string ex(str, iter.base());
   8924                                     assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000");
   8925                                     assert(ios.width() == 0);
   8926                                 }
   8927                             }
   8928                         }
   8929                     }
   8930                 }
   8931             }
   8932         }
   8933     }
   8934 }
   8935 
   8936 void test4()
   8937 {
   8938     char str[200];
   8939     output_iterator<char*> iter;
   8940     std::locale lc = std::locale::classic();
   8941     std::locale lg(lc, new my_numpunct);
   8942     const my_facet f(1);
   8943     {
   8944         long double v = -INFINITY;
   8945         std::ios ios(0);
   8946         // %g
   8947         {
   8948             ios.precision(0);
   8949             {
   8950                 nouppercase(ios);
   8951                 {
   8952                     noshowpos(ios);
   8953                     {
   8954                         noshowpoint(ios);
   8955                         {
   8956                             ios.imbue(lc);
   8957                             {
   8958                                 ios.width(0);
   8959                                 {
   8960                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8961                                     std::string ex(str, iter.base());
   8962                                     assert(ex == "-inf");
   8963                                     assert(ios.width() == 0);
   8964                                 }
   8965                                 ios.width(25);
   8966                                 left(ios);
   8967                                 {
   8968                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8969                                     std::string ex(str, iter.base());
   8970                                     assert(ex == "-inf*********************");
   8971                                     assert(ios.width() == 0);
   8972                                 }
   8973                                 ios.width(25);
   8974                                 right(ios);
   8975                                 {
   8976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8977                                     std::string ex(str, iter.base());
   8978                                     assert(ex == "*********************-inf");
   8979                                     assert(ios.width() == 0);
   8980                                 }
   8981                                 ios.width(25);
   8982                                 internal(ios);
   8983                                 {
   8984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8985                                     std::string ex(str, iter.base());
   8986                                     assert(ex == "-*********************inf");
   8987                                     assert(ios.width() == 0);
   8988                                 }
   8989                             }
   8990                             ios.imbue(lg);
   8991                             {
   8992                                 ios.width(0);
   8993                                 {
   8994                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   8995                                     std::string ex(str, iter.base());
   8996                                     assert(ex == "-inf");
   8997                                     assert(ios.width() == 0);
   8998                                 }
   8999                                 ios.width(25);
   9000                                 left(ios);
   9001                                 {
   9002                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9003                                     std::string ex(str, iter.base());
   9004                                     assert(ex == "-inf*********************");
   9005                                     assert(ios.width() == 0);
   9006                                 }
   9007                                 ios.width(25);
   9008                                 right(ios);
   9009                                 {
   9010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9011                                     std::string ex(str, iter.base());
   9012                                     assert(ex == "*********************-inf");
   9013                                     assert(ios.width() == 0);
   9014                                 }
   9015                                 ios.width(25);
   9016                                 internal(ios);
   9017                                 {
   9018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9019                                     std::string ex(str, iter.base());
   9020                                     assert(ex == "-*********************inf");
   9021                                     assert(ios.width() == 0);
   9022                                 }
   9023                             }
   9024                         }
   9025                         showpoint(ios);
   9026                         {
   9027                             ios.imbue(lc);
   9028                             {
   9029                                 ios.width(0);
   9030                                 {
   9031                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9032                                     std::string ex(str, iter.base());
   9033                                     assert(ex == "-inf");
   9034                                     assert(ios.width() == 0);
   9035                                 }
   9036                                 ios.width(25);
   9037                                 left(ios);
   9038                                 {
   9039                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9040                                     std::string ex(str, iter.base());
   9041                                     assert(ex == "-inf*********************");
   9042                                     assert(ios.width() == 0);
   9043                                 }
   9044                                 ios.width(25);
   9045                                 right(ios);
   9046                                 {
   9047                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9048                                     std::string ex(str, iter.base());
   9049                                     assert(ex == "*********************-inf");
   9050                                     assert(ios.width() == 0);
   9051                                 }
   9052                                 ios.width(25);
   9053                                 internal(ios);
   9054                                 {
   9055                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9056                                     std::string ex(str, iter.base());
   9057                                     assert(ex == "-*********************inf");
   9058                                     assert(ios.width() == 0);
   9059                                 }
   9060                             }
   9061                             ios.imbue(lg);
   9062                             {
   9063                                 ios.width(0);
   9064                                 {
   9065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9066                                     std::string ex(str, iter.base());
   9067                                     assert(ex == "-inf");
   9068                                     assert(ios.width() == 0);
   9069                                 }
   9070                                 ios.width(25);
   9071                                 left(ios);
   9072                                 {
   9073                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9074                                     std::string ex(str, iter.base());
   9075                                     assert(ex == "-inf*********************");
   9076                                     assert(ios.width() == 0);
   9077                                 }
   9078                                 ios.width(25);
   9079                                 right(ios);
   9080                                 {
   9081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9082                                     std::string ex(str, iter.base());
   9083                                     assert(ex == "*********************-inf");
   9084                                     assert(ios.width() == 0);
   9085                                 }
   9086                                 ios.width(25);
   9087                                 internal(ios);
   9088                                 {
   9089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9090                                     std::string ex(str, iter.base());
   9091                                     assert(ex == "-*********************inf");
   9092                                     assert(ios.width() == 0);
   9093                                 }
   9094                             }
   9095                         }
   9096                     }
   9097                     showpos(ios);
   9098                     {
   9099                         noshowpoint(ios);
   9100                         {
   9101                             ios.imbue(lc);
   9102                             {
   9103                                 ios.width(0);
   9104                                 {
   9105                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9106                                     std::string ex(str, iter.base());
   9107                                     assert(ex == "-inf");
   9108                                     assert(ios.width() == 0);
   9109                                 }
   9110                                 ios.width(25);
   9111                                 left(ios);
   9112                                 {
   9113                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9114                                     std::string ex(str, iter.base());
   9115                                     assert(ex == "-inf*********************");
   9116                                     assert(ios.width() == 0);
   9117                                 }
   9118                                 ios.width(25);
   9119                                 right(ios);
   9120                                 {
   9121                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9122                                     std::string ex(str, iter.base());
   9123                                     assert(ex == "*********************-inf");
   9124                                     assert(ios.width() == 0);
   9125                                 }
   9126                                 ios.width(25);
   9127                                 internal(ios);
   9128                                 {
   9129                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9130                                     std::string ex(str, iter.base());
   9131                                     assert(ex == "-*********************inf");
   9132                                     assert(ios.width() == 0);
   9133                                 }
   9134                             }
   9135                             ios.imbue(lg);
   9136                             {
   9137                                 ios.width(0);
   9138                                 {
   9139                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9140                                     std::string ex(str, iter.base());
   9141                                     assert(ex == "-inf");
   9142                                     assert(ios.width() == 0);
   9143                                 }
   9144                                 ios.width(25);
   9145                                 left(ios);
   9146                                 {
   9147                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9148                                     std::string ex(str, iter.base());
   9149                                     assert(ex == "-inf*********************");
   9150                                     assert(ios.width() == 0);
   9151                                 }
   9152                                 ios.width(25);
   9153                                 right(ios);
   9154                                 {
   9155                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9156                                     std::string ex(str, iter.base());
   9157                                     assert(ex == "*********************-inf");
   9158                                     assert(ios.width() == 0);
   9159                                 }
   9160                                 ios.width(25);
   9161                                 internal(ios);
   9162                                 {
   9163                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9164                                     std::string ex(str, iter.base());
   9165                                     assert(ex == "-*********************inf");
   9166                                     assert(ios.width() == 0);
   9167                                 }
   9168                             }
   9169                         }
   9170                         showpoint(ios);
   9171                         {
   9172                             ios.imbue(lc);
   9173                             {
   9174                                 ios.width(0);
   9175                                 {
   9176                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9177                                     std::string ex(str, iter.base());
   9178                                     assert(ex == "-inf");
   9179                                     assert(ios.width() == 0);
   9180                                 }
   9181                                 ios.width(25);
   9182                                 left(ios);
   9183                                 {
   9184                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9185                                     std::string ex(str, iter.base());
   9186                                     assert(ex == "-inf*********************");
   9187                                     assert(ios.width() == 0);
   9188                                 }
   9189                                 ios.width(25);
   9190                                 right(ios);
   9191                                 {
   9192                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9193                                     std::string ex(str, iter.base());
   9194                                     assert(ex == "*********************-inf");
   9195                                     assert(ios.width() == 0);
   9196                                 }
   9197                                 ios.width(25);
   9198                                 internal(ios);
   9199                                 {
   9200                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9201                                     std::string ex(str, iter.base());
   9202                                     assert(ex == "-*********************inf");
   9203                                     assert(ios.width() == 0);
   9204                                 }
   9205                             }
   9206                             ios.imbue(lg);
   9207                             {
   9208                                 ios.width(0);
   9209                                 {
   9210                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9211                                     std::string ex(str, iter.base());
   9212                                     assert(ex == "-inf");
   9213                                     assert(ios.width() == 0);
   9214                                 }
   9215                                 ios.width(25);
   9216                                 left(ios);
   9217                                 {
   9218                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9219                                     std::string ex(str, iter.base());
   9220                                     assert(ex == "-inf*********************");
   9221                                     assert(ios.width() == 0);
   9222                                 }
   9223                                 ios.width(25);
   9224                                 right(ios);
   9225                                 {
   9226                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9227                                     std::string ex(str, iter.base());
   9228                                     assert(ex == "*********************-inf");
   9229                                     assert(ios.width() == 0);
   9230                                 }
   9231                                 ios.width(25);
   9232                                 internal(ios);
   9233                                 {
   9234                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9235                                     std::string ex(str, iter.base());
   9236                                     assert(ex == "-*********************inf");
   9237                                     assert(ios.width() == 0);
   9238                                 }
   9239                             }
   9240                         }
   9241                     }
   9242                 }
   9243                 uppercase(ios);
   9244                 {
   9245                     noshowpos(ios);
   9246                     {
   9247                         noshowpoint(ios);
   9248                         {
   9249                             ios.imbue(lc);
   9250                             {
   9251                                 ios.width(0);
   9252                                 {
   9253                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9254                                     std::string ex(str, iter.base());
   9255                                     assert(ex == "-INF");
   9256                                     assert(ios.width() == 0);
   9257                                 }
   9258                                 ios.width(25);
   9259                                 left(ios);
   9260                                 {
   9261                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9262                                     std::string ex(str, iter.base());
   9263                                     assert(ex == "-INF*********************");
   9264                                     assert(ios.width() == 0);
   9265                                 }
   9266                                 ios.width(25);
   9267                                 right(ios);
   9268                                 {
   9269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9270                                     std::string ex(str, iter.base());
   9271                                     assert(ex == "*********************-INF");
   9272                                     assert(ios.width() == 0);
   9273                                 }
   9274                                 ios.width(25);
   9275                                 internal(ios);
   9276                                 {
   9277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9278                                     std::string ex(str, iter.base());
   9279                                     assert(ex == "-*********************INF");
   9280                                     assert(ios.width() == 0);
   9281                                 }
   9282                             }
   9283                             ios.imbue(lg);
   9284                             {
   9285                                 ios.width(0);
   9286                                 {
   9287                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9288                                     std::string ex(str, iter.base());
   9289                                     assert(ex == "-INF");
   9290                                     assert(ios.width() == 0);
   9291                                 }
   9292                                 ios.width(25);
   9293                                 left(ios);
   9294                                 {
   9295                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9296                                     std::string ex(str, iter.base());
   9297                                     assert(ex == "-INF*********************");
   9298                                     assert(ios.width() == 0);
   9299                                 }
   9300                                 ios.width(25);
   9301                                 right(ios);
   9302                                 {
   9303                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9304                                     std::string ex(str, iter.base());
   9305                                     assert(ex == "*********************-INF");
   9306                                     assert(ios.width() == 0);
   9307                                 }
   9308                                 ios.width(25);
   9309                                 internal(ios);
   9310                                 {
   9311                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9312                                     std::string ex(str, iter.base());
   9313                                     assert(ex == "-*********************INF");
   9314                                     assert(ios.width() == 0);
   9315                                 }
   9316                             }
   9317                         }
   9318                         showpoint(ios);
   9319                         {
   9320                             ios.imbue(lc);
   9321                             {
   9322                                 ios.width(0);
   9323                                 {
   9324                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9325                                     std::string ex(str, iter.base());
   9326                                     assert(ex == "-INF");
   9327                                     assert(ios.width() == 0);
   9328                                 }
   9329                                 ios.width(25);
   9330                                 left(ios);
   9331                                 {
   9332                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9333                                     std::string ex(str, iter.base());
   9334                                     assert(ex == "-INF*********************");
   9335                                     assert(ios.width() == 0);
   9336                                 }
   9337                                 ios.width(25);
   9338                                 right(ios);
   9339                                 {
   9340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9341                                     std::string ex(str, iter.base());
   9342                                     assert(ex == "*********************-INF");
   9343                                     assert(ios.width() == 0);
   9344                                 }
   9345                                 ios.width(25);
   9346                                 internal(ios);
   9347                                 {
   9348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9349                                     std::string ex(str, iter.base());
   9350                                     assert(ex == "-*********************INF");
   9351                                     assert(ios.width() == 0);
   9352                                 }
   9353                             }
   9354                             ios.imbue(lg);
   9355                             {
   9356                                 ios.width(0);
   9357                                 {
   9358                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9359                                     std::string ex(str, iter.base());
   9360                                     assert(ex == "-INF");
   9361                                     assert(ios.width() == 0);
   9362                                 }
   9363                                 ios.width(25);
   9364                                 left(ios);
   9365                                 {
   9366                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9367                                     std::string ex(str, iter.base());
   9368                                     assert(ex == "-INF*********************");
   9369                                     assert(ios.width() == 0);
   9370                                 }
   9371                                 ios.width(25);
   9372                                 right(ios);
   9373                                 {
   9374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9375                                     std::string ex(str, iter.base());
   9376                                     assert(ex == "*********************-INF");
   9377                                     assert(ios.width() == 0);
   9378                                 }
   9379                                 ios.width(25);
   9380                                 internal(ios);
   9381                                 {
   9382                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9383                                     std::string ex(str, iter.base());
   9384                                     assert(ex == "-*********************INF");
   9385                                     assert(ios.width() == 0);
   9386                                 }
   9387                             }
   9388                         }
   9389                     }
   9390                     showpos(ios);
   9391                     {
   9392                         noshowpoint(ios);
   9393                         {
   9394                             ios.imbue(lc);
   9395                             {
   9396                                 ios.width(0);
   9397                                 {
   9398                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9399                                     std::string ex(str, iter.base());
   9400                                     assert(ex == "-INF");
   9401                                     assert(ios.width() == 0);
   9402                                 }
   9403                                 ios.width(25);
   9404                                 left(ios);
   9405                                 {
   9406                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9407                                     std::string ex(str, iter.base());
   9408                                     assert(ex == "-INF*********************");
   9409                                     assert(ios.width() == 0);
   9410                                 }
   9411                                 ios.width(25);
   9412                                 right(ios);
   9413                                 {
   9414                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9415                                     std::string ex(str, iter.base());
   9416                                     assert(ex == "*********************-INF");
   9417                                     assert(ios.width() == 0);
   9418                                 }
   9419                                 ios.width(25);
   9420                                 internal(ios);
   9421                                 {
   9422                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9423                                     std::string ex(str, iter.base());
   9424                                     assert(ex == "-*********************INF");
   9425                                     assert(ios.width() == 0);
   9426                                 }
   9427                             }
   9428                             ios.imbue(lg);
   9429                             {
   9430                                 ios.width(0);
   9431                                 {
   9432                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9433                                     std::string ex(str, iter.base());
   9434                                     assert(ex == "-INF");
   9435                                     assert(ios.width() == 0);
   9436                                 }
   9437                                 ios.width(25);
   9438                                 left(ios);
   9439                                 {
   9440                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9441                                     std::string ex(str, iter.base());
   9442                                     assert(ex == "-INF*********************");
   9443                                     assert(ios.width() == 0);
   9444                                 }
   9445                                 ios.width(25);
   9446                                 right(ios);
   9447                                 {
   9448                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9449                                     std::string ex(str, iter.base());
   9450                                     assert(ex == "*********************-INF");
   9451                                     assert(ios.width() == 0);
   9452                                 }
   9453                                 ios.width(25);
   9454                                 internal(ios);
   9455                                 {
   9456                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9457                                     std::string ex(str, iter.base());
   9458                                     assert(ex == "-*********************INF");
   9459                                     assert(ios.width() == 0);
   9460                                 }
   9461                             }
   9462                         }
   9463                         showpoint(ios);
   9464                         {
   9465                             ios.imbue(lc);
   9466                             {
   9467                                 ios.width(0);
   9468                                 {
   9469                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9470                                     std::string ex(str, iter.base());
   9471                                     assert(ex == "-INF");
   9472                                     assert(ios.width() == 0);
   9473                                 }
   9474                                 ios.width(25);
   9475                                 left(ios);
   9476                                 {
   9477                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9478                                     std::string ex(str, iter.base());
   9479                                     assert(ex == "-INF*********************");
   9480                                     assert(ios.width() == 0);
   9481                                 }
   9482                                 ios.width(25);
   9483                                 right(ios);
   9484                                 {
   9485                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9486                                     std::string ex(str, iter.base());
   9487                                     assert(ex == "*********************-INF");
   9488                                     assert(ios.width() == 0);
   9489                                 }
   9490                                 ios.width(25);
   9491                                 internal(ios);
   9492                                 {
   9493                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9494                                     std::string ex(str, iter.base());
   9495                                     assert(ex == "-*********************INF");
   9496                                     assert(ios.width() == 0);
   9497                                 }
   9498                             }
   9499                             ios.imbue(lg);
   9500                             {
   9501                                 ios.width(0);
   9502                                 {
   9503                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9504                                     std::string ex(str, iter.base());
   9505                                     assert(ex == "-INF");
   9506                                     assert(ios.width() == 0);
   9507                                 }
   9508                                 ios.width(25);
   9509                                 left(ios);
   9510                                 {
   9511                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9512                                     std::string ex(str, iter.base());
   9513                                     assert(ex == "-INF*********************");
   9514                                     assert(ios.width() == 0);
   9515                                 }
   9516                                 ios.width(25);
   9517                                 right(ios);
   9518                                 {
   9519                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9520                                     std::string ex(str, iter.base());
   9521                                     assert(ex == "*********************-INF");
   9522                                     assert(ios.width() == 0);
   9523                                 }
   9524                                 ios.width(25);
   9525                                 internal(ios);
   9526                                 {
   9527                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9528                                     std::string ex(str, iter.base());
   9529                                     assert(ex == "-*********************INF");
   9530                                     assert(ios.width() == 0);
   9531                                 }
   9532                             }
   9533                         }
   9534                     }
   9535                 }
   9536             }
   9537             ios.precision(1);
   9538             {
   9539                 nouppercase(ios);
   9540                 {
   9541                     noshowpos(ios);
   9542                     {
   9543                         noshowpoint(ios);
   9544                         {
   9545                             ios.imbue(lc);
   9546                             {
   9547                                 ios.width(0);
   9548                                 {
   9549                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9550                                     std::string ex(str, iter.base());
   9551                                     assert(ex == "-inf");
   9552                                     assert(ios.width() == 0);
   9553                                 }
   9554                                 ios.width(25);
   9555                                 left(ios);
   9556                                 {
   9557                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9558                                     std::string ex(str, iter.base());
   9559                                     assert(ex == "-inf*********************");
   9560                                     assert(ios.width() == 0);
   9561                                 }
   9562                                 ios.width(25);
   9563                                 right(ios);
   9564                                 {
   9565                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9566                                     std::string ex(str, iter.base());
   9567                                     assert(ex == "*********************-inf");
   9568                                     assert(ios.width() == 0);
   9569                                 }
   9570                                 ios.width(25);
   9571                                 internal(ios);
   9572                                 {
   9573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9574                                     std::string ex(str, iter.base());
   9575                                     assert(ex == "-*********************inf");
   9576                                     assert(ios.width() == 0);
   9577                                 }
   9578                             }
   9579                             ios.imbue(lg);
   9580                             {
   9581                                 ios.width(0);
   9582                                 {
   9583                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9584                                     std::string ex(str, iter.base());
   9585                                     assert(ex == "-inf");
   9586                                     assert(ios.width() == 0);
   9587                                 }
   9588                                 ios.width(25);
   9589                                 left(ios);
   9590                                 {
   9591                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9592                                     std::string ex(str, iter.base());
   9593                                     assert(ex == "-inf*********************");
   9594                                     assert(ios.width() == 0);
   9595                                 }
   9596                                 ios.width(25);
   9597                                 right(ios);
   9598                                 {
   9599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9600                                     std::string ex(str, iter.base());
   9601                                     assert(ex == "*********************-inf");
   9602                                     assert(ios.width() == 0);
   9603                                 }
   9604                                 ios.width(25);
   9605                                 internal(ios);
   9606                                 {
   9607                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9608                                     std::string ex(str, iter.base());
   9609                                     assert(ex == "-*********************inf");
   9610                                     assert(ios.width() == 0);
   9611                                 }
   9612                             }
   9613                         }
   9614                         showpoint(ios);
   9615                         {
   9616                             ios.imbue(lc);
   9617                             {
   9618                                 ios.width(0);
   9619                                 {
   9620                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9621                                     std::string ex(str, iter.base());
   9622                                     assert(ex == "-inf");
   9623                                     assert(ios.width() == 0);
   9624                                 }
   9625                                 ios.width(25);
   9626                                 left(ios);
   9627                                 {
   9628                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9629                                     std::string ex(str, iter.base());
   9630                                     assert(ex == "-inf*********************");
   9631                                     assert(ios.width() == 0);
   9632                                 }
   9633                                 ios.width(25);
   9634                                 right(ios);
   9635                                 {
   9636                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9637                                     std::string ex(str, iter.base());
   9638                                     assert(ex == "*********************-inf");
   9639                                     assert(ios.width() == 0);
   9640                                 }
   9641                                 ios.width(25);
   9642                                 internal(ios);
   9643                                 {
   9644                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9645                                     std::string ex(str, iter.base());
   9646                                     assert(ex == "-*********************inf");
   9647                                     assert(ios.width() == 0);
   9648                                 }
   9649                             }
   9650                             ios.imbue(lg);
   9651                             {
   9652                                 ios.width(0);
   9653                                 {
   9654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9655                                     std::string ex(str, iter.base());
   9656                                     assert(ex == "-inf");
   9657                                     assert(ios.width() == 0);
   9658                                 }
   9659                                 ios.width(25);
   9660                                 left(ios);
   9661                                 {
   9662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9663                                     std::string ex(str, iter.base());
   9664                                     assert(ex == "-inf*********************");
   9665                                     assert(ios.width() == 0);
   9666                                 }
   9667                                 ios.width(25);
   9668                                 right(ios);
   9669                                 {
   9670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9671                                     std::string ex(str, iter.base());
   9672                                     assert(ex == "*********************-inf");
   9673                                     assert(ios.width() == 0);
   9674                                 }
   9675                                 ios.width(25);
   9676                                 internal(ios);
   9677                                 {
   9678                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9679                                     std::string ex(str, iter.base());
   9680                                     assert(ex == "-*********************inf");
   9681                                     assert(ios.width() == 0);
   9682                                 }
   9683                             }
   9684                         }
   9685                     }
   9686                     showpos(ios);
   9687                     {
   9688                         noshowpoint(ios);
   9689                         {
   9690                             ios.imbue(lc);
   9691                             {
   9692                                 ios.width(0);
   9693                                 {
   9694                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9695                                     std::string ex(str, iter.base());
   9696                                     assert(ex == "-inf");
   9697                                     assert(ios.width() == 0);
   9698                                 }
   9699                                 ios.width(25);
   9700                                 left(ios);
   9701                                 {
   9702                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9703                                     std::string ex(str, iter.base());
   9704                                     assert(ex == "-inf*********************");
   9705                                     assert(ios.width() == 0);
   9706                                 }
   9707                                 ios.width(25);
   9708                                 right(ios);
   9709                                 {
   9710                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9711                                     std::string ex(str, iter.base());
   9712                                     assert(ex == "*********************-inf");
   9713                                     assert(ios.width() == 0);
   9714                                 }
   9715                                 ios.width(25);
   9716                                 internal(ios);
   9717                                 {
   9718                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9719                                     std::string ex(str, iter.base());
   9720                                     assert(ex == "-*********************inf");
   9721                                     assert(ios.width() == 0);
   9722                                 }
   9723                             }
   9724                             ios.imbue(lg);
   9725                             {
   9726                                 ios.width(0);
   9727                                 {
   9728                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9729                                     std::string ex(str, iter.base());
   9730                                     assert(ex == "-inf");
   9731                                     assert(ios.width() == 0);
   9732                                 }
   9733                                 ios.width(25);
   9734                                 left(ios);
   9735                                 {
   9736                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9737                                     std::string ex(str, iter.base());
   9738                                     assert(ex == "-inf*********************");
   9739                                     assert(ios.width() == 0);
   9740                                 }
   9741                                 ios.width(25);
   9742                                 right(ios);
   9743                                 {
   9744                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9745                                     std::string ex(str, iter.base());
   9746                                     assert(ex == "*********************-inf");
   9747                                     assert(ios.width() == 0);
   9748                                 }
   9749                                 ios.width(25);
   9750                                 internal(ios);
   9751                                 {
   9752                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9753                                     std::string ex(str, iter.base());
   9754                                     assert(ex == "-*********************inf");
   9755                                     assert(ios.width() == 0);
   9756                                 }
   9757                             }
   9758                         }
   9759                         showpoint(ios);
   9760                         {
   9761                             ios.imbue(lc);
   9762                             {
   9763                                 ios.width(0);
   9764                                 {
   9765                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9766                                     std::string ex(str, iter.base());
   9767                                     assert(ex == "-inf");
   9768                                     assert(ios.width() == 0);
   9769                                 }
   9770                                 ios.width(25);
   9771                                 left(ios);
   9772                                 {
   9773                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9774                                     std::string ex(str, iter.base());
   9775                                     assert(ex == "-inf*********************");
   9776                                     assert(ios.width() == 0);
   9777                                 }
   9778                                 ios.width(25);
   9779                                 right(ios);
   9780                                 {
   9781                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9782                                     std::string ex(str, iter.base());
   9783                                     assert(ex == "*********************-inf");
   9784                                     assert(ios.width() == 0);
   9785                                 }
   9786                                 ios.width(25);
   9787                                 internal(ios);
   9788                                 {
   9789                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9790                                     std::string ex(str, iter.base());
   9791                                     assert(ex == "-*********************inf");
   9792                                     assert(ios.width() == 0);
   9793                                 }
   9794                             }
   9795                             ios.imbue(lg);
   9796                             {
   9797                                 ios.width(0);
   9798                                 {
   9799                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9800                                     std::string ex(str, iter.base());
   9801                                     assert(ex == "-inf");
   9802                                     assert(ios.width() == 0);
   9803                                 }
   9804                                 ios.width(25);
   9805                                 left(ios);
   9806                                 {
   9807                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9808                                     std::string ex(str, iter.base());
   9809                                     assert(ex == "-inf*********************");
   9810                                     assert(ios.width() == 0);
   9811                                 }
   9812                                 ios.width(25);
   9813                                 right(ios);
   9814                                 {
   9815                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9816                                     std::string ex(str, iter.base());
   9817                                     assert(ex == "*********************-inf");
   9818                                     assert(ios.width() == 0);
   9819                                 }
   9820                                 ios.width(25);
   9821                                 internal(ios);
   9822                                 {
   9823                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9824                                     std::string ex(str, iter.base());
   9825                                     assert(ex == "-*********************inf");
   9826                                     assert(ios.width() == 0);
   9827                                 }
   9828                             }
   9829                         }
   9830                     }
   9831                 }
   9832                 uppercase(ios);
   9833                 {
   9834                     noshowpos(ios);
   9835                     {
   9836                         noshowpoint(ios);
   9837                         {
   9838                             ios.imbue(lc);
   9839                             {
   9840                                 ios.width(0);
   9841                                 {
   9842                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9843                                     std::string ex(str, iter.base());
   9844                                     assert(ex == "-INF");
   9845                                     assert(ios.width() == 0);
   9846                                 }
   9847                                 ios.width(25);
   9848                                 left(ios);
   9849                                 {
   9850                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9851                                     std::string ex(str, iter.base());
   9852                                     assert(ex == "-INF*********************");
   9853                                     assert(ios.width() == 0);
   9854                                 }
   9855                                 ios.width(25);
   9856                                 right(ios);
   9857                                 {
   9858                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9859                                     std::string ex(str, iter.base());
   9860                                     assert(ex == "*********************-INF");
   9861                                     assert(ios.width() == 0);
   9862                                 }
   9863                                 ios.width(25);
   9864                                 internal(ios);
   9865                                 {
   9866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9867                                     std::string ex(str, iter.base());
   9868                                     assert(ex == "-*********************INF");
   9869                                     assert(ios.width() == 0);
   9870                                 }
   9871                             }
   9872                             ios.imbue(lg);
   9873                             {
   9874                                 ios.width(0);
   9875                                 {
   9876                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9877                                     std::string ex(str, iter.base());
   9878                                     assert(ex == "-INF");
   9879                                     assert(ios.width() == 0);
   9880                                 }
   9881                                 ios.width(25);
   9882                                 left(ios);
   9883                                 {
   9884                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9885                                     std::string ex(str, iter.base());
   9886                                     assert(ex == "-INF*********************");
   9887                                     assert(ios.width() == 0);
   9888                                 }
   9889                                 ios.width(25);
   9890                                 right(ios);
   9891                                 {
   9892                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9893                                     std::string ex(str, iter.base());
   9894                                     assert(ex == "*********************-INF");
   9895                                     assert(ios.width() == 0);
   9896                                 }
   9897                                 ios.width(25);
   9898                                 internal(ios);
   9899                                 {
   9900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9901                                     std::string ex(str, iter.base());
   9902                                     assert(ex == "-*********************INF");
   9903                                     assert(ios.width() == 0);
   9904                                 }
   9905                             }
   9906                         }
   9907                         showpoint(ios);
   9908                         {
   9909                             ios.imbue(lc);
   9910                             {
   9911                                 ios.width(0);
   9912                                 {
   9913                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9914                                     std::string ex(str, iter.base());
   9915                                     assert(ex == "-INF");
   9916                                     assert(ios.width() == 0);
   9917                                 }
   9918                                 ios.width(25);
   9919                                 left(ios);
   9920                                 {
   9921                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9922                                     std::string ex(str, iter.base());
   9923                                     assert(ex == "-INF*********************");
   9924                                     assert(ios.width() == 0);
   9925                                 }
   9926                                 ios.width(25);
   9927                                 right(ios);
   9928                                 {
   9929                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9930                                     std::string ex(str, iter.base());
   9931                                     assert(ex == "*********************-INF");
   9932                                     assert(ios.width() == 0);
   9933                                 }
   9934                                 ios.width(25);
   9935                                 internal(ios);
   9936                                 {
   9937                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9938                                     std::string ex(str, iter.base());
   9939                                     assert(ex == "-*********************INF");
   9940                                     assert(ios.width() == 0);
   9941                                 }
   9942                             }
   9943                             ios.imbue(lg);
   9944                             {
   9945                                 ios.width(0);
   9946                                 {
   9947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9948                                     std::string ex(str, iter.base());
   9949                                     assert(ex == "-INF");
   9950                                     assert(ios.width() == 0);
   9951                                 }
   9952                                 ios.width(25);
   9953                                 left(ios);
   9954                                 {
   9955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9956                                     std::string ex(str, iter.base());
   9957                                     assert(ex == "-INF*********************");
   9958                                     assert(ios.width() == 0);
   9959                                 }
   9960                                 ios.width(25);
   9961                                 right(ios);
   9962                                 {
   9963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9964                                     std::string ex(str, iter.base());
   9965                                     assert(ex == "*********************-INF");
   9966                                     assert(ios.width() == 0);
   9967                                 }
   9968                                 ios.width(25);
   9969                                 internal(ios);
   9970                                 {
   9971                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9972                                     std::string ex(str, iter.base());
   9973                                     assert(ex == "-*********************INF");
   9974                                     assert(ios.width() == 0);
   9975                                 }
   9976                             }
   9977                         }
   9978                     }
   9979                     showpos(ios);
   9980                     {
   9981                         noshowpoint(ios);
   9982                         {
   9983                             ios.imbue(lc);
   9984                             {
   9985                                 ios.width(0);
   9986                                 {
   9987                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9988                                     std::string ex(str, iter.base());
   9989                                     assert(ex == "-INF");
   9990                                     assert(ios.width() == 0);
   9991                                 }
   9992                                 ios.width(25);
   9993                                 left(ios);
   9994                                 {
   9995                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   9996                                     std::string ex(str, iter.base());
   9997                                     assert(ex == "-INF*********************");
   9998                                     assert(ios.width() == 0);
   9999                                 }
   10000                                 ios.width(25);
   10001                                 right(ios);
   10002                                 {
   10003                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10004                                     std::string ex(str, iter.base());
   10005                                     assert(ex == "*********************-INF");
   10006                                     assert(ios.width() == 0);
   10007                                 }
   10008                                 ios.width(25);
   10009                                 internal(ios);
   10010                                 {
   10011                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10012                                     std::string ex(str, iter.base());
   10013                                     assert(ex == "-*********************INF");
   10014                                     assert(ios.width() == 0);
   10015                                 }
   10016                             }
   10017                             ios.imbue(lg);
   10018                             {
   10019                                 ios.width(0);
   10020                                 {
   10021                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10022                                     std::string ex(str, iter.base());
   10023                                     assert(ex == "-INF");
   10024                                     assert(ios.width() == 0);
   10025                                 }
   10026                                 ios.width(25);
   10027                                 left(ios);
   10028                                 {
   10029                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10030                                     std::string ex(str, iter.base());
   10031                                     assert(ex == "-INF*********************");
   10032                                     assert(ios.width() == 0);
   10033                                 }
   10034                                 ios.width(25);
   10035                                 right(ios);
   10036                                 {
   10037                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10038                                     std::string ex(str, iter.base());
   10039                                     assert(ex == "*********************-INF");
   10040                                     assert(ios.width() == 0);
   10041                                 }
   10042                                 ios.width(25);
   10043                                 internal(ios);
   10044                                 {
   10045                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10046                                     std::string ex(str, iter.base());
   10047                                     assert(ex == "-*********************INF");
   10048                                     assert(ios.width() == 0);
   10049                                 }
   10050                             }
   10051                         }
   10052                         showpoint(ios);
   10053                         {
   10054                             ios.imbue(lc);
   10055                             {
   10056                                 ios.width(0);
   10057                                 {
   10058                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10059                                     std::string ex(str, iter.base());
   10060                                     assert(ex == "-INF");
   10061                                     assert(ios.width() == 0);
   10062                                 }
   10063                                 ios.width(25);
   10064                                 left(ios);
   10065                                 {
   10066                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10067                                     std::string ex(str, iter.base());
   10068                                     assert(ex == "-INF*********************");
   10069                                     assert(ios.width() == 0);
   10070                                 }
   10071                                 ios.width(25);
   10072                                 right(ios);
   10073                                 {
   10074                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10075                                     std::string ex(str, iter.base());
   10076                                     assert(ex == "*********************-INF");
   10077                                     assert(ios.width() == 0);
   10078                                 }
   10079                                 ios.width(25);
   10080                                 internal(ios);
   10081                                 {
   10082                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10083                                     std::string ex(str, iter.base());
   10084                                     assert(ex == "-*********************INF");
   10085                                     assert(ios.width() == 0);
   10086                                 }
   10087                             }
   10088                             ios.imbue(lg);
   10089                             {
   10090                                 ios.width(0);
   10091                                 {
   10092                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10093                                     std::string ex(str, iter.base());
   10094                                     assert(ex == "-INF");
   10095                                     assert(ios.width() == 0);
   10096                                 }
   10097                                 ios.width(25);
   10098                                 left(ios);
   10099                                 {
   10100                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10101                                     std::string ex(str, iter.base());
   10102                                     assert(ex == "-INF*********************");
   10103                                     assert(ios.width() == 0);
   10104                                 }
   10105                                 ios.width(25);
   10106                                 right(ios);
   10107                                 {
   10108                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10109                                     std::string ex(str, iter.base());
   10110                                     assert(ex == "*********************-INF");
   10111                                     assert(ios.width() == 0);
   10112                                 }
   10113                                 ios.width(25);
   10114                                 internal(ios);
   10115                                 {
   10116                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10117                                     std::string ex(str, iter.base());
   10118                                     assert(ex == "-*********************INF");
   10119                                     assert(ios.width() == 0);
   10120                                 }
   10121                             }
   10122                         }
   10123                     }
   10124                 }
   10125             }
   10126             ios.precision(6);
   10127             {
   10128                 nouppercase(ios);
   10129                 {
   10130                     noshowpos(ios);
   10131                     {
   10132                         noshowpoint(ios);
   10133                         {
   10134                             ios.imbue(lc);
   10135                             {
   10136                                 ios.width(0);
   10137                                 {
   10138                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10139                                     std::string ex(str, iter.base());
   10140                                     assert(ex == "-inf");
   10141                                     assert(ios.width() == 0);
   10142                                 }
   10143                                 ios.width(25);
   10144                                 left(ios);
   10145                                 {
   10146                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10147                                     std::string ex(str, iter.base());
   10148                                     assert(ex == "-inf*********************");
   10149                                     assert(ios.width() == 0);
   10150                                 }
   10151                                 ios.width(25);
   10152                                 right(ios);
   10153                                 {
   10154                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10155                                     std::string ex(str, iter.base());
   10156                                     assert(ex == "*********************-inf");
   10157                                     assert(ios.width() == 0);
   10158                                 }
   10159                                 ios.width(25);
   10160                                 internal(ios);
   10161                                 {
   10162                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10163                                     std::string ex(str, iter.base());
   10164                                     assert(ex == "-*********************inf");
   10165                                     assert(ios.width() == 0);
   10166                                 }
   10167                             }
   10168                             ios.imbue(lg);
   10169                             {
   10170                                 ios.width(0);
   10171                                 {
   10172                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10173                                     std::string ex(str, iter.base());
   10174                                     assert(ex == "-inf");
   10175                                     assert(ios.width() == 0);
   10176                                 }
   10177                                 ios.width(25);
   10178                                 left(ios);
   10179                                 {
   10180                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10181                                     std::string ex(str, iter.base());
   10182                                     assert(ex == "-inf*********************");
   10183                                     assert(ios.width() == 0);
   10184                                 }
   10185                                 ios.width(25);
   10186                                 right(ios);
   10187                                 {
   10188                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10189                                     std::string ex(str, iter.base());
   10190                                     assert(ex == "*********************-inf");
   10191                                     assert(ios.width() == 0);
   10192                                 }
   10193                                 ios.width(25);
   10194                                 internal(ios);
   10195                                 {
   10196                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10197                                     std::string ex(str, iter.base());
   10198                                     assert(ex == "-*********************inf");
   10199                                     assert(ios.width() == 0);
   10200                                 }
   10201                             }
   10202                         }
   10203                         showpoint(ios);
   10204                         {
   10205                             ios.imbue(lc);
   10206                             {
   10207                                 ios.width(0);
   10208                                 {
   10209                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10210                                     std::string ex(str, iter.base());
   10211                                     assert(ex == "-inf");
   10212                                     assert(ios.width() == 0);
   10213                                 }
   10214                                 ios.width(25);
   10215                                 left(ios);
   10216                                 {
   10217                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10218                                     std::string ex(str, iter.base());
   10219                                     assert(ex == "-inf*********************");
   10220                                     assert(ios.width() == 0);
   10221                                 }
   10222                                 ios.width(25);
   10223                                 right(ios);
   10224                                 {
   10225                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10226                                     std::string ex(str, iter.base());
   10227                                     assert(ex == "*********************-inf");
   10228                                     assert(ios.width() == 0);
   10229                                 }
   10230                                 ios.width(25);
   10231                                 internal(ios);
   10232                                 {
   10233                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10234                                     std::string ex(str, iter.base());
   10235                                     assert(ex == "-*********************inf");
   10236                                     assert(ios.width() == 0);
   10237                                 }
   10238                             }
   10239                             ios.imbue(lg);
   10240                             {
   10241                                 ios.width(0);
   10242                                 {
   10243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10244                                     std::string ex(str, iter.base());
   10245                                     assert(ex == "-inf");
   10246                                     assert(ios.width() == 0);
   10247                                 }
   10248                                 ios.width(25);
   10249                                 left(ios);
   10250                                 {
   10251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10252                                     std::string ex(str, iter.base());
   10253                                     assert(ex == "-inf*********************");
   10254                                     assert(ios.width() == 0);
   10255                                 }
   10256                                 ios.width(25);
   10257                                 right(ios);
   10258                                 {
   10259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10260                                     std::string ex(str, iter.base());
   10261                                     assert(ex == "*********************-inf");
   10262                                     assert(ios.width() == 0);
   10263                                 }
   10264                                 ios.width(25);
   10265                                 internal(ios);
   10266                                 {
   10267                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10268                                     std::string ex(str, iter.base());
   10269                                     assert(ex == "-*********************inf");
   10270                                     assert(ios.width() == 0);
   10271                                 }
   10272                             }
   10273                         }
   10274                     }
   10275                     showpos(ios);
   10276                     {
   10277                         noshowpoint(ios);
   10278                         {
   10279                             ios.imbue(lc);
   10280                             {
   10281                                 ios.width(0);
   10282                                 {
   10283                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10284                                     std::string ex(str, iter.base());
   10285                                     assert(ex == "-inf");
   10286                                     assert(ios.width() == 0);
   10287                                 }
   10288                                 ios.width(25);
   10289                                 left(ios);
   10290                                 {
   10291                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10292                                     std::string ex(str, iter.base());
   10293                                     assert(ex == "-inf*********************");
   10294                                     assert(ios.width() == 0);
   10295                                 }
   10296                                 ios.width(25);
   10297                                 right(ios);
   10298                                 {
   10299                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10300                                     std::string ex(str, iter.base());
   10301                                     assert(ex == "*********************-inf");
   10302                                     assert(ios.width() == 0);
   10303                                 }
   10304                                 ios.width(25);
   10305                                 internal(ios);
   10306                                 {
   10307                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10308                                     std::string ex(str, iter.base());
   10309                                     assert(ex == "-*********************inf");
   10310                                     assert(ios.width() == 0);
   10311                                 }
   10312                             }
   10313                             ios.imbue(lg);
   10314                             {
   10315                                 ios.width(0);
   10316                                 {
   10317                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10318                                     std::string ex(str, iter.base());
   10319                                     assert(ex == "-inf");
   10320                                     assert(ios.width() == 0);
   10321                                 }
   10322                                 ios.width(25);
   10323                                 left(ios);
   10324                                 {
   10325                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10326                                     std::string ex(str, iter.base());
   10327                                     assert(ex == "-inf*********************");
   10328                                     assert(ios.width() == 0);
   10329                                 }
   10330                                 ios.width(25);
   10331                                 right(ios);
   10332                                 {
   10333                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10334                                     std::string ex(str, iter.base());
   10335                                     assert(ex == "*********************-inf");
   10336                                     assert(ios.width() == 0);
   10337                                 }
   10338                                 ios.width(25);
   10339                                 internal(ios);
   10340                                 {
   10341                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10342                                     std::string ex(str, iter.base());
   10343                                     assert(ex == "-*********************inf");
   10344                                     assert(ios.width() == 0);
   10345                                 }
   10346                             }
   10347                         }
   10348                         showpoint(ios);
   10349                         {
   10350                             ios.imbue(lc);
   10351                             {
   10352                                 ios.width(0);
   10353                                 {
   10354                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10355                                     std::string ex(str, iter.base());
   10356                                     assert(ex == "-inf");
   10357                                     assert(ios.width() == 0);
   10358                                 }
   10359                                 ios.width(25);
   10360                                 left(ios);
   10361                                 {
   10362                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10363                                     std::string ex(str, iter.base());
   10364                                     assert(ex == "-inf*********************");
   10365                                     assert(ios.width() == 0);
   10366                                 }
   10367                                 ios.width(25);
   10368                                 right(ios);
   10369                                 {
   10370                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10371                                     std::string ex(str, iter.base());
   10372                                     assert(ex == "*********************-inf");
   10373                                     assert(ios.width() == 0);
   10374                                 }
   10375                                 ios.width(25);
   10376                                 internal(ios);
   10377                                 {
   10378                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10379                                     std::string ex(str, iter.base());
   10380                                     assert(ex == "-*********************inf");
   10381                                     assert(ios.width() == 0);
   10382                                 }
   10383                             }
   10384                             ios.imbue(lg);
   10385                             {
   10386                                 ios.width(0);
   10387                                 {
   10388                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10389                                     std::string ex(str, iter.base());
   10390                                     assert(ex == "-inf");
   10391                                     assert(ios.width() == 0);
   10392                                 }
   10393                                 ios.width(25);
   10394                                 left(ios);
   10395                                 {
   10396                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10397                                     std::string ex(str, iter.base());
   10398                                     assert(ex == "-inf*********************");
   10399                                     assert(ios.width() == 0);
   10400                                 }
   10401                                 ios.width(25);
   10402                                 right(ios);
   10403                                 {
   10404                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10405                                     std::string ex(str, iter.base());
   10406                                     assert(ex == "*********************-inf");
   10407                                     assert(ios.width() == 0);
   10408                                 }
   10409                                 ios.width(25);
   10410                                 internal(ios);
   10411                                 {
   10412                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10413                                     std::string ex(str, iter.base());
   10414                                     assert(ex == "-*********************inf");
   10415                                     assert(ios.width() == 0);
   10416                                 }
   10417                             }
   10418                         }
   10419                     }
   10420                 }
   10421                 uppercase(ios);
   10422                 {
   10423                     noshowpos(ios);
   10424                     {
   10425                         noshowpoint(ios);
   10426                         {
   10427                             ios.imbue(lc);
   10428                             {
   10429                                 ios.width(0);
   10430                                 {
   10431                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10432                                     std::string ex(str, iter.base());
   10433                                     assert(ex == "-INF");
   10434                                     assert(ios.width() == 0);
   10435                                 }
   10436                                 ios.width(25);
   10437                                 left(ios);
   10438                                 {
   10439                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10440                                     std::string ex(str, iter.base());
   10441                                     assert(ex == "-INF*********************");
   10442                                     assert(ios.width() == 0);
   10443                                 }
   10444                                 ios.width(25);
   10445                                 right(ios);
   10446                                 {
   10447                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10448                                     std::string ex(str, iter.base());
   10449                                     assert(ex == "*********************-INF");
   10450                                     assert(ios.width() == 0);
   10451                                 }
   10452                                 ios.width(25);
   10453                                 internal(ios);
   10454                                 {
   10455                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10456                                     std::string ex(str, iter.base());
   10457                                     assert(ex == "-*********************INF");
   10458                                     assert(ios.width() == 0);
   10459                                 }
   10460                             }
   10461                             ios.imbue(lg);
   10462                             {
   10463                                 ios.width(0);
   10464                                 {
   10465                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10466                                     std::string ex(str, iter.base());
   10467                                     assert(ex == "-INF");
   10468                                     assert(ios.width() == 0);
   10469                                 }
   10470                                 ios.width(25);
   10471                                 left(ios);
   10472                                 {
   10473                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10474                                     std::string ex(str, iter.base());
   10475                                     assert(ex == "-INF*********************");
   10476                                     assert(ios.width() == 0);
   10477                                 }
   10478                                 ios.width(25);
   10479                                 right(ios);
   10480                                 {
   10481                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10482                                     std::string ex(str, iter.base());
   10483                                     assert(ex == "*********************-INF");
   10484                                     assert(ios.width() == 0);
   10485                                 }
   10486                                 ios.width(25);
   10487                                 internal(ios);
   10488                                 {
   10489                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10490                                     std::string ex(str, iter.base());
   10491                                     assert(ex == "-*********************INF");
   10492                                     assert(ios.width() == 0);
   10493                                 }
   10494                             }
   10495                         }
   10496                         showpoint(ios);
   10497                         {
   10498                             ios.imbue(lc);
   10499                             {
   10500                                 ios.width(0);
   10501                                 {
   10502                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10503                                     std::string ex(str, iter.base());
   10504                                     assert(ex == "-INF");
   10505                                     assert(ios.width() == 0);
   10506                                 }
   10507                                 ios.width(25);
   10508                                 left(ios);
   10509                                 {
   10510                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10511                                     std::string ex(str, iter.base());
   10512                                     assert(ex == "-INF*********************");
   10513                                     assert(ios.width() == 0);
   10514                                 }
   10515                                 ios.width(25);
   10516                                 right(ios);
   10517                                 {
   10518                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10519                                     std::string ex(str, iter.base());
   10520                                     assert(ex == "*********************-INF");
   10521                                     assert(ios.width() == 0);
   10522                                 }
   10523                                 ios.width(25);
   10524                                 internal(ios);
   10525                                 {
   10526                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10527                                     std::string ex(str, iter.base());
   10528                                     assert(ex == "-*********************INF");
   10529                                     assert(ios.width() == 0);
   10530                                 }
   10531                             }
   10532                             ios.imbue(lg);
   10533                             {
   10534                                 ios.width(0);
   10535                                 {
   10536                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10537                                     std::string ex(str, iter.base());
   10538                                     assert(ex == "-INF");
   10539                                     assert(ios.width() == 0);
   10540                                 }
   10541                                 ios.width(25);
   10542                                 left(ios);
   10543                                 {
   10544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10545                                     std::string ex(str, iter.base());
   10546                                     assert(ex == "-INF*********************");
   10547                                     assert(ios.width() == 0);
   10548                                 }
   10549                                 ios.width(25);
   10550                                 right(ios);
   10551                                 {
   10552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10553                                     std::string ex(str, iter.base());
   10554                                     assert(ex == "*********************-INF");
   10555                                     assert(ios.width() == 0);
   10556                                 }
   10557                                 ios.width(25);
   10558                                 internal(ios);
   10559                                 {
   10560                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10561                                     std::string ex(str, iter.base());
   10562                                     assert(ex == "-*********************INF");
   10563                                     assert(ios.width() == 0);
   10564                                 }
   10565                             }
   10566                         }
   10567                     }
   10568                     showpos(ios);
   10569                     {
   10570                         noshowpoint(ios);
   10571                         {
   10572                             ios.imbue(lc);
   10573                             {
   10574                                 ios.width(0);
   10575                                 {
   10576                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10577                                     std::string ex(str, iter.base());
   10578                                     assert(ex == "-INF");
   10579                                     assert(ios.width() == 0);
   10580                                 }
   10581                                 ios.width(25);
   10582                                 left(ios);
   10583                                 {
   10584                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10585                                     std::string ex(str, iter.base());
   10586                                     assert(ex == "-INF*********************");
   10587                                     assert(ios.width() == 0);
   10588                                 }
   10589                                 ios.width(25);
   10590                                 right(ios);
   10591                                 {
   10592                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10593                                     std::string ex(str, iter.base());
   10594                                     assert(ex == "*********************-INF");
   10595                                     assert(ios.width() == 0);
   10596                                 }
   10597                                 ios.width(25);
   10598                                 internal(ios);
   10599                                 {
   10600                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10601                                     std::string ex(str, iter.base());
   10602                                     assert(ex == "-*********************INF");
   10603                                     assert(ios.width() == 0);
   10604                                 }
   10605                             }
   10606                             ios.imbue(lg);
   10607                             {
   10608                                 ios.width(0);
   10609                                 {
   10610                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10611                                     std::string ex(str, iter.base());
   10612                                     assert(ex == "-INF");
   10613                                     assert(ios.width() == 0);
   10614                                 }
   10615                                 ios.width(25);
   10616                                 left(ios);
   10617                                 {
   10618                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10619                                     std::string ex(str, iter.base());
   10620                                     assert(ex == "-INF*********************");
   10621                                     assert(ios.width() == 0);
   10622                                 }
   10623                                 ios.width(25);
   10624                                 right(ios);
   10625                                 {
   10626                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10627                                     std::string ex(str, iter.base());
   10628                                     assert(ex == "*********************-INF");
   10629                                     assert(ios.width() == 0);
   10630                                 }
   10631                                 ios.width(25);
   10632                                 internal(ios);
   10633                                 {
   10634                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10635                                     std::string ex(str, iter.base());
   10636                                     assert(ex == "-*********************INF");
   10637                                     assert(ios.width() == 0);
   10638                                 }
   10639                             }
   10640                         }
   10641                         showpoint(ios);
   10642                         {
   10643                             ios.imbue(lc);
   10644                             {
   10645                                 ios.width(0);
   10646                                 {
   10647                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10648                                     std::string ex(str, iter.base());
   10649                                     assert(ex == "-INF");
   10650                                     assert(ios.width() == 0);
   10651                                 }
   10652                                 ios.width(25);
   10653                                 left(ios);
   10654                                 {
   10655                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10656                                     std::string ex(str, iter.base());
   10657                                     assert(ex == "-INF*********************");
   10658                                     assert(ios.width() == 0);
   10659                                 }
   10660                                 ios.width(25);
   10661                                 right(ios);
   10662                                 {
   10663                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10664                                     std::string ex(str, iter.base());
   10665                                     assert(ex == "*********************-INF");
   10666                                     assert(ios.width() == 0);
   10667                                 }
   10668                                 ios.width(25);
   10669                                 internal(ios);
   10670                                 {
   10671                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10672                                     std::string ex(str, iter.base());
   10673                                     assert(ex == "-*********************INF");
   10674                                     assert(ios.width() == 0);
   10675                                 }
   10676                             }
   10677                             ios.imbue(lg);
   10678                             {
   10679                                 ios.width(0);
   10680                                 {
   10681                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10682                                     std::string ex(str, iter.base());
   10683                                     assert(ex == "-INF");
   10684                                     assert(ios.width() == 0);
   10685                                 }
   10686                                 ios.width(25);
   10687                                 left(ios);
   10688                                 {
   10689                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10690                                     std::string ex(str, iter.base());
   10691                                     assert(ex == "-INF*********************");
   10692                                     assert(ios.width() == 0);
   10693                                 }
   10694                                 ios.width(25);
   10695                                 right(ios);
   10696                                 {
   10697                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10698                                     std::string ex(str, iter.base());
   10699                                     assert(ex == "*********************-INF");
   10700                                     assert(ios.width() == 0);
   10701                                 }
   10702                                 ios.width(25);
   10703                                 internal(ios);
   10704                                 {
   10705                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10706                                     std::string ex(str, iter.base());
   10707                                     assert(ex == "-*********************INF");
   10708                                     assert(ios.width() == 0);
   10709                                 }
   10710                             }
   10711                         }
   10712                     }
   10713                 }
   10714             }
   10715             ios.precision(16);
   10716             {}
   10717             ios.precision(60);
   10718             {}
   10719         }
   10720     }
   10721 }
   10722 
   10723 void test5()
   10724 {
   10725     char str[200];
   10726     output_iterator<char*> iter;
   10727     std::locale lc = std::locale::classic();
   10728     std::locale lg(lc, new my_numpunct);
   10729     const my_facet f(1);
   10730     {
   10731         long double v = std::nan("");
   10732         std::ios ios(0);
   10733         // %g
   10734         {
   10735             ios.precision(0);
   10736             {
   10737                 nouppercase(ios);
   10738                 {
   10739                     noshowpos(ios);
   10740                     {
   10741                         noshowpoint(ios);
   10742                         {
   10743                             ios.imbue(lc);
   10744                             {
   10745                                 ios.width(0);
   10746                                 {
   10747                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10748                                     std::string ex(str, iter.base());
   10749                                     assert(ex == "nan");
   10750                                     assert(ios.width() == 0);
   10751                                 }
   10752                                 ios.width(25);
   10753                                 left(ios);
   10754                                 {
   10755                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10756                                     std::string ex(str, iter.base());
   10757                                     assert(ex == "nan**********************");
   10758                                     assert(ios.width() == 0);
   10759                                 }
   10760                                 ios.width(25);
   10761                                 right(ios);
   10762                                 {
   10763                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10764                                     std::string ex(str, iter.base());
   10765                                     assert(ex == "**********************nan");
   10766                                     assert(ios.width() == 0);
   10767                                 }
   10768                                 ios.width(25);
   10769                                 internal(ios);
   10770                                 {
   10771                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10772                                     std::string ex(str, iter.base());
   10773                                     assert(ex == "**********************nan");
   10774                                     assert(ios.width() == 0);
   10775                                 }
   10776                             }
   10777                             ios.imbue(lg);
   10778                             {
   10779                                 ios.width(0);
   10780                                 {
   10781                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10782                                     std::string ex(str, iter.base());
   10783                                     assert(ex == "nan");
   10784                                     assert(ios.width() == 0);
   10785                                 }
   10786                                 ios.width(25);
   10787                                 left(ios);
   10788                                 {
   10789                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10790                                     std::string ex(str, iter.base());
   10791                                     assert(ex == "nan**********************");
   10792                                     assert(ios.width() == 0);
   10793                                 }
   10794                                 ios.width(25);
   10795                                 right(ios);
   10796                                 {
   10797                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10798                                     std::string ex(str, iter.base());
   10799                                     assert(ex == "**********************nan");
   10800                                     assert(ios.width() == 0);
   10801                                 }
   10802                                 ios.width(25);
   10803                                 internal(ios);
   10804                                 {
   10805                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10806                                     std::string ex(str, iter.base());
   10807                                     assert(ex == "**********************nan");
   10808                                     assert(ios.width() == 0);
   10809                                 }
   10810                             }
   10811                         }
   10812                         showpoint(ios);
   10813                         {
   10814                             ios.imbue(lc);
   10815                             {
   10816                                 ios.width(0);
   10817                                 {
   10818                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10819                                     std::string ex(str, iter.base());
   10820                                     assert(ex == "nan");
   10821                                     assert(ios.width() == 0);
   10822                                 }
   10823                                 ios.width(25);
   10824                                 left(ios);
   10825                                 {
   10826                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10827                                     std::string ex(str, iter.base());
   10828                                     assert(ex == "nan**********************");
   10829                                     assert(ios.width() == 0);
   10830                                 }
   10831                                 ios.width(25);
   10832                                 right(ios);
   10833                                 {
   10834                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10835                                     std::string ex(str, iter.base());
   10836                                     assert(ex == "**********************nan");
   10837                                     assert(ios.width() == 0);
   10838                                 }
   10839                                 ios.width(25);
   10840                                 internal(ios);
   10841                                 {
   10842                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10843                                     std::string ex(str, iter.base());
   10844                                     assert(ex == "**********************nan");
   10845                                     assert(ios.width() == 0);
   10846                                 }
   10847                             }
   10848                             ios.imbue(lg);
   10849                             {
   10850                                 ios.width(0);
   10851                                 {
   10852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10853                                     std::string ex(str, iter.base());
   10854                                     assert(ex == "nan");
   10855                                     assert(ios.width() == 0);
   10856                                 }
   10857                                 ios.width(25);
   10858                                 left(ios);
   10859                                 {
   10860                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10861                                     std::string ex(str, iter.base());
   10862                                     assert(ex == "nan**********************");
   10863                                     assert(ios.width() == 0);
   10864                                 }
   10865                                 ios.width(25);
   10866                                 right(ios);
   10867                                 {
   10868                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10869                                     std::string ex(str, iter.base());
   10870                                     assert(ex == "**********************nan");
   10871                                     assert(ios.width() == 0);
   10872                                 }
   10873                                 ios.width(25);
   10874                                 internal(ios);
   10875                                 {
   10876                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10877                                     std::string ex(str, iter.base());
   10878                                     assert(ex == "**********************nan");
   10879                                     assert(ios.width() == 0);
   10880                                 }
   10881                             }
   10882                         }
   10883                     }
   10884                     showpos(ios);
   10885                     {
   10886                         noshowpoint(ios);
   10887                         {
   10888                             ios.imbue(lc);
   10889                             {
   10890                                 ios.width(0);
   10891                                 {
   10892                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10893                                     std::string ex(str, iter.base());
   10894                                     assert(ex == "nan");
   10895                                     assert(ios.width() == 0);
   10896                                 }
   10897                                 ios.width(25);
   10898                                 left(ios);
   10899                                 {
   10900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10901                                     std::string ex(str, iter.base());
   10902                                     assert(ex == "nan**********************");
   10903                                     assert(ios.width() == 0);
   10904                                 }
   10905                                 ios.width(25);
   10906                                 right(ios);
   10907                                 {
   10908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10909                                     std::string ex(str, iter.base());
   10910                                     assert(ex == "**********************nan");
   10911                                     assert(ios.width() == 0);
   10912                                 }
   10913                                 ios.width(25);
   10914                                 internal(ios);
   10915                                 {
   10916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10917                                     std::string ex(str, iter.base());
   10918                                     assert(ex == "**********************nan");
   10919                                     assert(ios.width() == 0);
   10920                                 }
   10921                             }
   10922                             ios.imbue(lg);
   10923                             {
   10924                                 ios.width(0);
   10925                                 {
   10926                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10927                                     std::string ex(str, iter.base());
   10928                                     assert(ex == "nan");
   10929                                     assert(ios.width() == 0);
   10930                                 }
   10931                                 ios.width(25);
   10932                                 left(ios);
   10933                                 {
   10934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10935                                     std::string ex(str, iter.base());
   10936                                     assert(ex == "nan**********************");
   10937                                     assert(ios.width() == 0);
   10938                                 }
   10939                                 ios.width(25);
   10940                                 right(ios);
   10941                                 {
   10942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10943                                     std::string ex(str, iter.base());
   10944                                     assert(ex == "**********************nan");
   10945                                     assert(ios.width() == 0);
   10946                                 }
   10947                                 ios.width(25);
   10948                                 internal(ios);
   10949                                 {
   10950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10951                                     std::string ex(str, iter.base());
   10952                                     assert(ex == "**********************nan");
   10953                                     assert(ios.width() == 0);
   10954                                 }
   10955                             }
   10956                         }
   10957                         showpoint(ios);
   10958                         {
   10959                             ios.imbue(lc);
   10960                             {
   10961                                 ios.width(0);
   10962                                 {
   10963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10964                                     std::string ex(str, iter.base());
   10965                                     assert(ex == "nan");
   10966                                     assert(ios.width() == 0);
   10967                                 }
   10968                                 ios.width(25);
   10969                                 left(ios);
   10970                                 {
   10971                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10972                                     std::string ex(str, iter.base());
   10973                                     assert(ex == "nan**********************");
   10974                                     assert(ios.width() == 0);
   10975                                 }
   10976                                 ios.width(25);
   10977                                 right(ios);
   10978                                 {
   10979                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10980                                     std::string ex(str, iter.base());
   10981                                     assert(ex == "**********************nan");
   10982                                     assert(ios.width() == 0);
   10983                                 }
   10984                                 ios.width(25);
   10985                                 internal(ios);
   10986                                 {
   10987                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10988                                     std::string ex(str, iter.base());
   10989                                     assert(ex == "**********************nan");
   10990                                     assert(ios.width() == 0);
   10991                                 }
   10992                             }
   10993                             ios.imbue(lg);
   10994                             {
   10995                                 ios.width(0);
   10996                                 {
   10997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   10998                                     std::string ex(str, iter.base());
   10999                                     assert(ex == "nan");
   11000                                     assert(ios.width() == 0);
   11001                                 }
   11002                                 ios.width(25);
   11003                                 left(ios);
   11004                                 {
   11005                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11006                                     std::string ex(str, iter.base());
   11007                                     assert(ex == "nan**********************");
   11008                                     assert(ios.width() == 0);
   11009                                 }
   11010                                 ios.width(25);
   11011                                 right(ios);
   11012                                 {
   11013                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11014                                     std::string ex(str, iter.base());
   11015                                     assert(ex == "**********************nan");
   11016                                     assert(ios.width() == 0);
   11017                                 }
   11018                                 ios.width(25);
   11019                                 internal(ios);
   11020                                 {
   11021                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11022                                     std::string ex(str, iter.base());
   11023                                     assert(ex == "**********************nan");
   11024                                     assert(ios.width() == 0);
   11025                                 }
   11026                             }
   11027                         }
   11028                     }
   11029                 }
   11030                 uppercase(ios);
   11031                 {
   11032                     noshowpos(ios);
   11033                     {
   11034                         noshowpoint(ios);
   11035                         {
   11036                             ios.imbue(lc);
   11037                             {
   11038                                 ios.width(0);
   11039                                 {
   11040                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11041                                     std::string ex(str, iter.base());
   11042                                     assert(ex == "NAN");
   11043                                     assert(ios.width() == 0);
   11044                                 }
   11045                                 ios.width(25);
   11046                                 left(ios);
   11047                                 {
   11048                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11049                                     std::string ex(str, iter.base());
   11050                                     assert(ex == "NAN**********************");
   11051                                     assert(ios.width() == 0);
   11052                                 }
   11053                                 ios.width(25);
   11054                                 right(ios);
   11055                                 {
   11056                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11057                                     std::string ex(str, iter.base());
   11058                                     assert(ex == "**********************NAN");
   11059                                     assert(ios.width() == 0);
   11060                                 }
   11061                                 ios.width(25);
   11062                                 internal(ios);
   11063                                 {
   11064                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11065                                     std::string ex(str, iter.base());
   11066                                     assert(ex == "**********************NAN");
   11067                                     assert(ios.width() == 0);
   11068                                 }
   11069                             }
   11070                             ios.imbue(lg);
   11071                             {
   11072                                 ios.width(0);
   11073                                 {
   11074                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11075                                     std::string ex(str, iter.base());
   11076                                     assert(ex == "NAN");
   11077                                     assert(ios.width() == 0);
   11078                                 }
   11079                                 ios.width(25);
   11080                                 left(ios);
   11081                                 {
   11082                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11083                                     std::string ex(str, iter.base());
   11084                                     assert(ex == "NAN**********************");
   11085                                     assert(ios.width() == 0);
   11086                                 }
   11087                                 ios.width(25);
   11088                                 right(ios);
   11089                                 {
   11090                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11091                                     std::string ex(str, iter.base());
   11092                                     assert(ex == "**********************NAN");
   11093                                     assert(ios.width() == 0);
   11094                                 }
   11095                                 ios.width(25);
   11096                                 internal(ios);
   11097                                 {
   11098                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11099                                     std::string ex(str, iter.base());
   11100                                     assert(ex == "**********************NAN");
   11101                                     assert(ios.width() == 0);
   11102                                 }
   11103                             }
   11104                         }
   11105                         showpoint(ios);
   11106                         {
   11107                             ios.imbue(lc);
   11108                             {
   11109                                 ios.width(0);
   11110                                 {
   11111                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11112                                     std::string ex(str, iter.base());
   11113                                     assert(ex == "NAN");
   11114                                     assert(ios.width() == 0);
   11115                                 }
   11116                                 ios.width(25);
   11117                                 left(ios);
   11118                                 {
   11119                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11120                                     std::string ex(str, iter.base());
   11121                                     assert(ex == "NAN**********************");
   11122                                     assert(ios.width() == 0);
   11123                                 }
   11124                                 ios.width(25);
   11125                                 right(ios);
   11126                                 {
   11127                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11128                                     std::string ex(str, iter.base());
   11129                                     assert(ex == "**********************NAN");
   11130                                     assert(ios.width() == 0);
   11131                                 }
   11132                                 ios.width(25);
   11133                                 internal(ios);
   11134                                 {
   11135                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11136                                     std::string ex(str, iter.base());
   11137                                     assert(ex == "**********************NAN");
   11138                                     assert(ios.width() == 0);
   11139                                 }
   11140                             }
   11141                             ios.imbue(lg);
   11142                             {
   11143                                 ios.width(0);
   11144                                 {
   11145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11146                                     std::string ex(str, iter.base());
   11147                                     assert(ex == "NAN");
   11148                                     assert(ios.width() == 0);
   11149                                 }
   11150                                 ios.width(25);
   11151                                 left(ios);
   11152                                 {
   11153                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11154                                     std::string ex(str, iter.base());
   11155                                     assert(ex == "NAN**********************");
   11156                                     assert(ios.width() == 0);
   11157                                 }
   11158                                 ios.width(25);
   11159                                 right(ios);
   11160                                 {
   11161                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11162                                     std::string ex(str, iter.base());
   11163                                     assert(ex == "**********************NAN");
   11164                                     assert(ios.width() == 0);
   11165                                 }
   11166                                 ios.width(25);
   11167                                 internal(ios);
   11168                                 {
   11169                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11170                                     std::string ex(str, iter.base());
   11171                                     assert(ex == "**********************NAN");
   11172                                     assert(ios.width() == 0);
   11173                                 }
   11174                             }
   11175                         }
   11176                     }
   11177                     showpos(ios);
   11178                     {
   11179                         noshowpoint(ios);
   11180                         {
   11181                             ios.imbue(lc);
   11182                             {
   11183                                 ios.width(0);
   11184                                 {
   11185                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11186                                     std::string ex(str, iter.base());
   11187                                     assert(ex == "NAN");
   11188                                     assert(ios.width() == 0);
   11189                                 }
   11190                                 ios.width(25);
   11191                                 left(ios);
   11192                                 {
   11193                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11194                                     std::string ex(str, iter.base());
   11195                                     assert(ex == "NAN**********************");
   11196                                     assert(ios.width() == 0);
   11197                                 }
   11198                                 ios.width(25);
   11199                                 right(ios);
   11200                                 {
   11201                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11202                                     std::string ex(str, iter.base());
   11203                                     assert(ex == "**********************NAN");
   11204                                     assert(ios.width() == 0);
   11205                                 }
   11206                                 ios.width(25);
   11207                                 internal(ios);
   11208                                 {
   11209                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11210                                     std::string ex(str, iter.base());
   11211                                     assert(ex == "**********************NAN");
   11212                                     assert(ios.width() == 0);
   11213                                 }
   11214                             }
   11215                             ios.imbue(lg);
   11216                             {
   11217                                 ios.width(0);
   11218                                 {
   11219                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11220                                     std::string ex(str, iter.base());
   11221                                     assert(ex == "NAN");
   11222                                     assert(ios.width() == 0);
   11223                                 }
   11224                                 ios.width(25);
   11225                                 left(ios);
   11226                                 {
   11227                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11228                                     std::string ex(str, iter.base());
   11229                                     assert(ex == "NAN**********************");
   11230                                     assert(ios.width() == 0);
   11231                                 }
   11232                                 ios.width(25);
   11233                                 right(ios);
   11234                                 {
   11235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11236                                     std::string ex(str, iter.base());
   11237                                     assert(ex == "**********************NAN");
   11238                                     assert(ios.width() == 0);
   11239                                 }
   11240                                 ios.width(25);
   11241                                 internal(ios);
   11242                                 {
   11243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11244                                     std::string ex(str, iter.base());
   11245                                     assert(ex == "**********************NAN");
   11246                                     assert(ios.width() == 0);
   11247                                 }
   11248                             }
   11249                         }
   11250                         showpoint(ios);
   11251                         {
   11252                             ios.imbue(lc);
   11253                             {
   11254                                 ios.width(0);
   11255                                 {
   11256                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11257                                     std::string ex(str, iter.base());
   11258                                     assert(ex == "NAN");
   11259                                     assert(ios.width() == 0);
   11260                                 }
   11261                                 ios.width(25);
   11262                                 left(ios);
   11263                                 {
   11264                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11265                                     std::string ex(str, iter.base());
   11266                                     assert(ex == "NAN**********************");
   11267                                     assert(ios.width() == 0);
   11268                                 }
   11269                                 ios.width(25);
   11270                                 right(ios);
   11271                                 {
   11272                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11273                                     std::string ex(str, iter.base());
   11274                                     assert(ex == "**********************NAN");
   11275                                     assert(ios.width() == 0);
   11276                                 }
   11277                                 ios.width(25);
   11278                                 internal(ios);
   11279                                 {
   11280                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11281                                     std::string ex(str, iter.base());
   11282                                     assert(ex == "**********************NAN");
   11283                                     assert(ios.width() == 0);
   11284                                 }
   11285                             }
   11286                             ios.imbue(lg);
   11287                             {
   11288                                 ios.width(0);
   11289                                 {
   11290                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11291                                     std::string ex(str, iter.base());
   11292                                     assert(ex == "NAN");
   11293                                     assert(ios.width() == 0);
   11294                                 }
   11295                                 ios.width(25);
   11296                                 left(ios);
   11297                                 {
   11298                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11299                                     std::string ex(str, iter.base());
   11300                                     assert(ex == "NAN**********************");
   11301                                     assert(ios.width() == 0);
   11302                                 }
   11303                                 ios.width(25);
   11304                                 right(ios);
   11305                                 {
   11306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11307                                     std::string ex(str, iter.base());
   11308                                     assert(ex == "**********************NAN");
   11309                                     assert(ios.width() == 0);
   11310                                 }
   11311                                 ios.width(25);
   11312                                 internal(ios);
   11313                                 {
   11314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11315                                     std::string ex(str, iter.base());
   11316                                     assert(ex == "**********************NAN");
   11317                                     assert(ios.width() == 0);
   11318                                 }
   11319                             }
   11320                         }
   11321                     }
   11322                 }
   11323             }
   11324             ios.precision(1);
   11325             {}
   11326             ios.precision(6);
   11327             {}
   11328             ios.precision(16);
   11329             {}
   11330             ios.precision(60);
   11331             {}
   11332         }
   11333     }
   11334 }
   11335 
   11336 void test6()
   11337 {
   11338     char str[200];
   11339     output_iterator<char*> iter;
   11340     std::locale lc = std::locale::classic();
   11341     std::locale lg(lc, new my_numpunct);
   11342     const my_facet f(1);
   11343     {
   11344         long double v = +0.;
   11345         std::ios ios(0);
   11346         fixed(ios);
   11347         // %f
   11348         {
   11349             ios.precision(0);
   11350             {
   11351                 nouppercase(ios);
   11352                 {
   11353                     noshowpos(ios);
   11354                     {
   11355                         noshowpoint(ios);
   11356                         {
   11357                             ios.imbue(lc);
   11358                             {
   11359                                 ios.width(0);
   11360                                 {
   11361                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11362                                     std::string ex(str, iter.base());
   11363                                     assert(ex == "0");
   11364                                     assert(ios.width() == 0);
   11365                                 }
   11366                                 ios.width(25);
   11367                                 left(ios);
   11368                                 {
   11369                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11370                                     std::string ex(str, iter.base());
   11371                                     assert(ex == "0************************");
   11372                                     assert(ios.width() == 0);
   11373                                 }
   11374                                 ios.width(25);
   11375                                 right(ios);
   11376                                 {
   11377                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11378                                     std::string ex(str, iter.base());
   11379                                     assert(ex == "************************0");
   11380                                     assert(ios.width() == 0);
   11381                                 }
   11382                                 ios.width(25);
   11383                                 internal(ios);
   11384                                 {
   11385                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11386                                     std::string ex(str, iter.base());
   11387                                     assert(ex == "************************0");
   11388                                     assert(ios.width() == 0);
   11389                                 }
   11390                             }
   11391                             ios.imbue(lg);
   11392                             {
   11393                                 ios.width(0);
   11394                                 {
   11395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11396                                     std::string ex(str, iter.base());
   11397                                     assert(ex == "0");
   11398                                     assert(ios.width() == 0);
   11399                                 }
   11400                                 ios.width(25);
   11401                                 left(ios);
   11402                                 {
   11403                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11404                                     std::string ex(str, iter.base());
   11405                                     assert(ex == "0************************");
   11406                                     assert(ios.width() == 0);
   11407                                 }
   11408                                 ios.width(25);
   11409                                 right(ios);
   11410                                 {
   11411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11412                                     std::string ex(str, iter.base());
   11413                                     assert(ex == "************************0");
   11414                                     assert(ios.width() == 0);
   11415                                 }
   11416                                 ios.width(25);
   11417                                 internal(ios);
   11418                                 {
   11419                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11420                                     std::string ex(str, iter.base());
   11421                                     assert(ex == "************************0");
   11422                                     assert(ios.width() == 0);
   11423                                 }
   11424                             }
   11425                         }
   11426                         showpoint(ios);
   11427                         {
   11428                             ios.imbue(lc);
   11429                             {
   11430                                 ios.width(0);
   11431                                 {
   11432                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11433                                     std::string ex(str, iter.base());
   11434                                     assert(ex == "0.");
   11435                                     assert(ios.width() == 0);
   11436                                 }
   11437                                 ios.width(25);
   11438                                 left(ios);
   11439                                 {
   11440                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11441                                     std::string ex(str, iter.base());
   11442                                     assert(ex == "0.***********************");
   11443                                     assert(ios.width() == 0);
   11444                                 }
   11445                                 ios.width(25);
   11446                                 right(ios);
   11447                                 {
   11448                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11449                                     std::string ex(str, iter.base());
   11450                                     assert(ex == "***********************0.");
   11451                                     assert(ios.width() == 0);
   11452                                 }
   11453                                 ios.width(25);
   11454                                 internal(ios);
   11455                                 {
   11456                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11457                                     std::string ex(str, iter.base());
   11458                                     assert(ex == "***********************0.");
   11459                                     assert(ios.width() == 0);
   11460                                 }
   11461                             }
   11462                             ios.imbue(lg);
   11463                             {
   11464                                 ios.width(0);
   11465                                 {
   11466                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11467                                     std::string ex(str, iter.base());
   11468                                     assert(ex == "0;");
   11469                                     assert(ios.width() == 0);
   11470                                 }
   11471                                 ios.width(25);
   11472                                 left(ios);
   11473                                 {
   11474                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11475                                     std::string ex(str, iter.base());
   11476                                     assert(ex == "0;***********************");
   11477                                     assert(ios.width() == 0);
   11478                                 }
   11479                                 ios.width(25);
   11480                                 right(ios);
   11481                                 {
   11482                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11483                                     std::string ex(str, iter.base());
   11484                                     assert(ex == "***********************0;");
   11485                                     assert(ios.width() == 0);
   11486                                 }
   11487                                 ios.width(25);
   11488                                 internal(ios);
   11489                                 {
   11490                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11491                                     std::string ex(str, iter.base());
   11492                                     assert(ex == "***********************0;");
   11493                                     assert(ios.width() == 0);
   11494                                 }
   11495                             }
   11496                         }
   11497                     }
   11498                     showpos(ios);
   11499                     {
   11500                         noshowpoint(ios);
   11501                         {
   11502                             ios.imbue(lc);
   11503                             {
   11504                                 ios.width(0);
   11505                                 {
   11506                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11507                                     std::string ex(str, iter.base());
   11508                                     assert(ex == "+0");
   11509                                     assert(ios.width() == 0);
   11510                                 }
   11511                                 ios.width(25);
   11512                                 left(ios);
   11513                                 {
   11514                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11515                                     std::string ex(str, iter.base());
   11516                                     assert(ex == "+0***********************");
   11517                                     assert(ios.width() == 0);
   11518                                 }
   11519                                 ios.width(25);
   11520                                 right(ios);
   11521                                 {
   11522                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11523                                     std::string ex(str, iter.base());
   11524                                     assert(ex == "***********************+0");
   11525                                     assert(ios.width() == 0);
   11526                                 }
   11527                                 ios.width(25);
   11528                                 internal(ios);
   11529                                 {
   11530                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11531                                     std::string ex(str, iter.base());
   11532                                     assert(ex == "+***********************0");
   11533                                     assert(ios.width() == 0);
   11534                                 }
   11535                             }
   11536                             ios.imbue(lg);
   11537                             {
   11538                                 ios.width(0);
   11539                                 {
   11540                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11541                                     std::string ex(str, iter.base());
   11542                                     assert(ex == "+0");
   11543                                     assert(ios.width() == 0);
   11544                                 }
   11545                                 ios.width(25);
   11546                                 left(ios);
   11547                                 {
   11548                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11549                                     std::string ex(str, iter.base());
   11550                                     assert(ex == "+0***********************");
   11551                                     assert(ios.width() == 0);
   11552                                 }
   11553                                 ios.width(25);
   11554                                 right(ios);
   11555                                 {
   11556                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11557                                     std::string ex(str, iter.base());
   11558                                     assert(ex == "***********************+0");
   11559                                     assert(ios.width() == 0);
   11560                                 }
   11561                                 ios.width(25);
   11562                                 internal(ios);
   11563                                 {
   11564                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11565                                     std::string ex(str, iter.base());
   11566                                     assert(ex == "+***********************0");
   11567                                     assert(ios.width() == 0);
   11568                                 }
   11569                             }
   11570                         }
   11571                         showpoint(ios);
   11572                         {
   11573                             ios.imbue(lc);
   11574                             {
   11575                                 ios.width(0);
   11576                                 {
   11577                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11578                                     std::string ex(str, iter.base());
   11579                                     assert(ex == "+0.");
   11580                                     assert(ios.width() == 0);
   11581                                 }
   11582                                 ios.width(25);
   11583                                 left(ios);
   11584                                 {
   11585                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11586                                     std::string ex(str, iter.base());
   11587                                     assert(ex == "+0.**********************");
   11588                                     assert(ios.width() == 0);
   11589                                 }
   11590                                 ios.width(25);
   11591                                 right(ios);
   11592                                 {
   11593                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11594                                     std::string ex(str, iter.base());
   11595                                     assert(ex == "**********************+0.");
   11596                                     assert(ios.width() == 0);
   11597                                 }
   11598                                 ios.width(25);
   11599                                 internal(ios);
   11600                                 {
   11601                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11602                                     std::string ex(str, iter.base());
   11603                                     assert(ex == "+**********************0.");
   11604                                     assert(ios.width() == 0);
   11605                                 }
   11606                             }
   11607                             ios.imbue(lg);
   11608                             {
   11609                                 ios.width(0);
   11610                                 {
   11611                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11612                                     std::string ex(str, iter.base());
   11613                                     assert(ex == "+0;");
   11614                                     assert(ios.width() == 0);
   11615                                 }
   11616                                 ios.width(25);
   11617                                 left(ios);
   11618                                 {
   11619                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11620                                     std::string ex(str, iter.base());
   11621                                     assert(ex == "+0;**********************");
   11622                                     assert(ios.width() == 0);
   11623                                 }
   11624                                 ios.width(25);
   11625                                 right(ios);
   11626                                 {
   11627                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11628                                     std::string ex(str, iter.base());
   11629                                     assert(ex == "**********************+0;");
   11630                                     assert(ios.width() == 0);
   11631                                 }
   11632                                 ios.width(25);
   11633                                 internal(ios);
   11634                                 {
   11635                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11636                                     std::string ex(str, iter.base());
   11637                                     assert(ex == "+**********************0;");
   11638                                     assert(ios.width() == 0);
   11639                                 }
   11640                             }
   11641                         }
   11642                     }
   11643                 }
   11644                 uppercase(ios);
   11645                 {
   11646                     noshowpos(ios);
   11647                     {
   11648                         noshowpoint(ios);
   11649                         {
   11650                             ios.imbue(lc);
   11651                             {
   11652                                 ios.width(0);
   11653                                 {
   11654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11655                                     std::string ex(str, iter.base());
   11656                                     assert(ex == "0");
   11657                                     assert(ios.width() == 0);
   11658                                 }
   11659                                 ios.width(25);
   11660                                 left(ios);
   11661                                 {
   11662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11663                                     std::string ex(str, iter.base());
   11664                                     assert(ex == "0************************");
   11665                                     assert(ios.width() == 0);
   11666                                 }
   11667                                 ios.width(25);
   11668                                 right(ios);
   11669                                 {
   11670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11671                                     std::string ex(str, iter.base());
   11672                                     assert(ex == "************************0");
   11673                                     assert(ios.width() == 0);
   11674                                 }
   11675                                 ios.width(25);
   11676                                 internal(ios);
   11677                                 {
   11678                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11679                                     std::string ex(str, iter.base());
   11680                                     assert(ex == "************************0");
   11681                                     assert(ios.width() == 0);
   11682                                 }
   11683                             }
   11684                             ios.imbue(lg);
   11685                             {
   11686                                 ios.width(0);
   11687                                 {
   11688                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11689                                     std::string ex(str, iter.base());
   11690                                     assert(ex == "0");
   11691                                     assert(ios.width() == 0);
   11692                                 }
   11693                                 ios.width(25);
   11694                                 left(ios);
   11695                                 {
   11696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11697                                     std::string ex(str, iter.base());
   11698                                     assert(ex == "0************************");
   11699                                     assert(ios.width() == 0);
   11700                                 }
   11701                                 ios.width(25);
   11702                                 right(ios);
   11703                                 {
   11704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11705                                     std::string ex(str, iter.base());
   11706                                     assert(ex == "************************0");
   11707                                     assert(ios.width() == 0);
   11708                                 }
   11709                                 ios.width(25);
   11710                                 internal(ios);
   11711                                 {
   11712                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11713                                     std::string ex(str, iter.base());
   11714                                     assert(ex == "************************0");
   11715                                     assert(ios.width() == 0);
   11716                                 }
   11717                             }
   11718                         }
   11719                         showpoint(ios);
   11720                         {
   11721                             ios.imbue(lc);
   11722                             {
   11723                                 ios.width(0);
   11724                                 {
   11725                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11726                                     std::string ex(str, iter.base());
   11727                                     assert(ex == "0.");
   11728                                     assert(ios.width() == 0);
   11729                                 }
   11730                                 ios.width(25);
   11731                                 left(ios);
   11732                                 {
   11733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11734                                     std::string ex(str, iter.base());
   11735                                     assert(ex == "0.***********************");
   11736                                     assert(ios.width() == 0);
   11737                                 }
   11738                                 ios.width(25);
   11739                                 right(ios);
   11740                                 {
   11741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11742                                     std::string ex(str, iter.base());
   11743                                     assert(ex == "***********************0.");
   11744                                     assert(ios.width() == 0);
   11745                                 }
   11746                                 ios.width(25);
   11747                                 internal(ios);
   11748                                 {
   11749                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11750                                     std::string ex(str, iter.base());
   11751                                     assert(ex == "***********************0.");
   11752                                     assert(ios.width() == 0);
   11753                                 }
   11754                             }
   11755                             ios.imbue(lg);
   11756                             {
   11757                                 ios.width(0);
   11758                                 {
   11759                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11760                                     std::string ex(str, iter.base());
   11761                                     assert(ex == "0;");
   11762                                     assert(ios.width() == 0);
   11763                                 }
   11764                                 ios.width(25);
   11765                                 left(ios);
   11766                                 {
   11767                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11768                                     std::string ex(str, iter.base());
   11769                                     assert(ex == "0;***********************");
   11770                                     assert(ios.width() == 0);
   11771                                 }
   11772                                 ios.width(25);
   11773                                 right(ios);
   11774                                 {
   11775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11776                                     std::string ex(str, iter.base());
   11777                                     assert(ex == "***********************0;");
   11778                                     assert(ios.width() == 0);
   11779                                 }
   11780                                 ios.width(25);
   11781                                 internal(ios);
   11782                                 {
   11783                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11784                                     std::string ex(str, iter.base());
   11785                                     assert(ex == "***********************0;");
   11786                                     assert(ios.width() == 0);
   11787                                 }
   11788                             }
   11789                         }
   11790                     }
   11791                     showpos(ios);
   11792                     {
   11793                         noshowpoint(ios);
   11794                         {
   11795                             ios.imbue(lc);
   11796                             {
   11797                                 ios.width(0);
   11798                                 {
   11799                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11800                                     std::string ex(str, iter.base());
   11801                                     assert(ex == "+0");
   11802                                     assert(ios.width() == 0);
   11803                                 }
   11804                                 ios.width(25);
   11805                                 left(ios);
   11806                                 {
   11807                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11808                                     std::string ex(str, iter.base());
   11809                                     assert(ex == "+0***********************");
   11810                                     assert(ios.width() == 0);
   11811                                 }
   11812                                 ios.width(25);
   11813                                 right(ios);
   11814                                 {
   11815                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11816                                     std::string ex(str, iter.base());
   11817                                     assert(ex == "***********************+0");
   11818                                     assert(ios.width() == 0);
   11819                                 }
   11820                                 ios.width(25);
   11821                                 internal(ios);
   11822                                 {
   11823                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11824                                     std::string ex(str, iter.base());
   11825                                     assert(ex == "+***********************0");
   11826                                     assert(ios.width() == 0);
   11827                                 }
   11828                             }
   11829                             ios.imbue(lg);
   11830                             {
   11831                                 ios.width(0);
   11832                                 {
   11833                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11834                                     std::string ex(str, iter.base());
   11835                                     assert(ex == "+0");
   11836                                     assert(ios.width() == 0);
   11837                                 }
   11838                                 ios.width(25);
   11839                                 left(ios);
   11840                                 {
   11841                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11842                                     std::string ex(str, iter.base());
   11843                                     assert(ex == "+0***********************");
   11844                                     assert(ios.width() == 0);
   11845                                 }
   11846                                 ios.width(25);
   11847                                 right(ios);
   11848                                 {
   11849                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11850                                     std::string ex(str, iter.base());
   11851                                     assert(ex == "***********************+0");
   11852                                     assert(ios.width() == 0);
   11853                                 }
   11854                                 ios.width(25);
   11855                                 internal(ios);
   11856                                 {
   11857                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11858                                     std::string ex(str, iter.base());
   11859                                     assert(ex == "+***********************0");
   11860                                     assert(ios.width() == 0);
   11861                                 }
   11862                             }
   11863                         }
   11864                         showpoint(ios);
   11865                         {
   11866                             ios.imbue(lc);
   11867                             {
   11868                                 ios.width(0);
   11869                                 {
   11870                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11871                                     std::string ex(str, iter.base());
   11872                                     assert(ex == "+0.");
   11873                                     assert(ios.width() == 0);
   11874                                 }
   11875                                 ios.width(25);
   11876                                 left(ios);
   11877                                 {
   11878                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11879                                     std::string ex(str, iter.base());
   11880                                     assert(ex == "+0.**********************");
   11881                                     assert(ios.width() == 0);
   11882                                 }
   11883                                 ios.width(25);
   11884                                 right(ios);
   11885                                 {
   11886                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11887                                     std::string ex(str, iter.base());
   11888                                     assert(ex == "**********************+0.");
   11889                                     assert(ios.width() == 0);
   11890                                 }
   11891                                 ios.width(25);
   11892                                 internal(ios);
   11893                                 {
   11894                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11895                                     std::string ex(str, iter.base());
   11896                                     assert(ex == "+**********************0.");
   11897                                     assert(ios.width() == 0);
   11898                                 }
   11899                             }
   11900                             ios.imbue(lg);
   11901                             {
   11902                                 ios.width(0);
   11903                                 {
   11904                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11905                                     std::string ex(str, iter.base());
   11906                                     assert(ex == "+0;");
   11907                                     assert(ios.width() == 0);
   11908                                 }
   11909                                 ios.width(25);
   11910                                 left(ios);
   11911                                 {
   11912                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11913                                     std::string ex(str, iter.base());
   11914                                     assert(ex == "+0;**********************");
   11915                                     assert(ios.width() == 0);
   11916                                 }
   11917                                 ios.width(25);
   11918                                 right(ios);
   11919                                 {
   11920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11921                                     std::string ex(str, iter.base());
   11922                                     assert(ex == "**********************+0;");
   11923                                     assert(ios.width() == 0);
   11924                                 }
   11925                                 ios.width(25);
   11926                                 internal(ios);
   11927                                 {
   11928                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11929                                     std::string ex(str, iter.base());
   11930                                     assert(ex == "+**********************0;");
   11931                                     assert(ios.width() == 0);
   11932                                 }
   11933                             }
   11934                         }
   11935                     }
   11936                 }
   11937             }
   11938             ios.precision(1);
   11939             {
   11940                 nouppercase(ios);
   11941                 {
   11942                     noshowpos(ios);
   11943                     {
   11944                         noshowpoint(ios);
   11945                         {
   11946                             ios.imbue(lc);
   11947                             {
   11948                                 ios.width(0);
   11949                                 {
   11950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11951                                     std::string ex(str, iter.base());
   11952                                     assert(ex == "0.0");
   11953                                     assert(ios.width() == 0);
   11954                                 }
   11955                                 ios.width(25);
   11956                                 left(ios);
   11957                                 {
   11958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11959                                     std::string ex(str, iter.base());
   11960                                     assert(ex == "0.0**********************");
   11961                                     assert(ios.width() == 0);
   11962                                 }
   11963                                 ios.width(25);
   11964                                 right(ios);
   11965                                 {
   11966                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11967                                     std::string ex(str, iter.base());
   11968                                     assert(ex == "**********************0.0");
   11969                                     assert(ios.width() == 0);
   11970                                 }
   11971                                 ios.width(25);
   11972                                 internal(ios);
   11973                                 {
   11974                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11975                                     std::string ex(str, iter.base());
   11976                                     assert(ex == "**********************0.0");
   11977                                     assert(ios.width() == 0);
   11978                                 }
   11979                             }
   11980                             ios.imbue(lg);
   11981                             {
   11982                                 ios.width(0);
   11983                                 {
   11984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11985                                     std::string ex(str, iter.base());
   11986                                     assert(ex == "0;0");
   11987                                     assert(ios.width() == 0);
   11988                                 }
   11989                                 ios.width(25);
   11990                                 left(ios);
   11991                                 {
   11992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   11993                                     std::string ex(str, iter.base());
   11994                                     assert(ex == "0;0**********************");
   11995                                     assert(ios.width() == 0);
   11996                                 }
   11997                                 ios.width(25);
   11998                                 right(ios);
   11999                                 {
   12000                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12001                                     std::string ex(str, iter.base());
   12002                                     assert(ex == "**********************0;0");
   12003                                     assert(ios.width() == 0);
   12004                                 }
   12005                                 ios.width(25);
   12006                                 internal(ios);
   12007                                 {
   12008                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12009                                     std::string ex(str, iter.base());
   12010                                     assert(ex == "**********************0;0");
   12011                                     assert(ios.width() == 0);
   12012                                 }
   12013                             }
   12014                         }
   12015                         showpoint(ios);
   12016                         {
   12017                             ios.imbue(lc);
   12018                             {
   12019                                 ios.width(0);
   12020                                 {
   12021                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12022                                     std::string ex(str, iter.base());
   12023                                     assert(ex == "0.0");
   12024                                     assert(ios.width() == 0);
   12025                                 }
   12026                                 ios.width(25);
   12027                                 left(ios);
   12028                                 {
   12029                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12030                                     std::string ex(str, iter.base());
   12031                                     assert(ex == "0.0**********************");
   12032                                     assert(ios.width() == 0);
   12033                                 }
   12034                                 ios.width(25);
   12035                                 right(ios);
   12036                                 {
   12037                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12038                                     std::string ex(str, iter.base());
   12039                                     assert(ex == "**********************0.0");
   12040                                     assert(ios.width() == 0);
   12041                                 }
   12042                                 ios.width(25);
   12043                                 internal(ios);
   12044                                 {
   12045                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12046                                     std::string ex(str, iter.base());
   12047                                     assert(ex == "**********************0.0");
   12048                                     assert(ios.width() == 0);
   12049                                 }
   12050                             }
   12051                             ios.imbue(lg);
   12052                             {
   12053                                 ios.width(0);
   12054                                 {
   12055                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12056                                     std::string ex(str, iter.base());
   12057                                     assert(ex == "0;0");
   12058                                     assert(ios.width() == 0);
   12059                                 }
   12060                                 ios.width(25);
   12061                                 left(ios);
   12062                                 {
   12063                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12064                                     std::string ex(str, iter.base());
   12065                                     assert(ex == "0;0**********************");
   12066                                     assert(ios.width() == 0);
   12067                                 }
   12068                                 ios.width(25);
   12069                                 right(ios);
   12070                                 {
   12071                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12072                                     std::string ex(str, iter.base());
   12073                                     assert(ex == "**********************0;0");
   12074                                     assert(ios.width() == 0);
   12075                                 }
   12076                                 ios.width(25);
   12077                                 internal(ios);
   12078                                 {
   12079                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12080                                     std::string ex(str, iter.base());
   12081                                     assert(ex == "**********************0;0");
   12082                                     assert(ios.width() == 0);
   12083                                 }
   12084                             }
   12085                         }
   12086                     }
   12087                     showpos(ios);
   12088                     {
   12089                         noshowpoint(ios);
   12090                         {
   12091                             ios.imbue(lc);
   12092                             {
   12093                                 ios.width(0);
   12094                                 {
   12095                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12096                                     std::string ex(str, iter.base());
   12097                                     assert(ex == "+0.0");
   12098                                     assert(ios.width() == 0);
   12099                                 }
   12100                                 ios.width(25);
   12101                                 left(ios);
   12102                                 {
   12103                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12104                                     std::string ex(str, iter.base());
   12105                                     assert(ex == "+0.0*********************");
   12106                                     assert(ios.width() == 0);
   12107                                 }
   12108                                 ios.width(25);
   12109                                 right(ios);
   12110                                 {
   12111                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12112                                     std::string ex(str, iter.base());
   12113                                     assert(ex == "*********************+0.0");
   12114                                     assert(ios.width() == 0);
   12115                                 }
   12116                                 ios.width(25);
   12117                                 internal(ios);
   12118                                 {
   12119                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12120                                     std::string ex(str, iter.base());
   12121                                     assert(ex == "+*********************0.0");
   12122                                     assert(ios.width() == 0);
   12123                                 }
   12124                             }
   12125                             ios.imbue(lg);
   12126                             {
   12127                                 ios.width(0);
   12128                                 {
   12129                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12130                                     std::string ex(str, iter.base());
   12131                                     assert(ex == "+0;0");
   12132                                     assert(ios.width() == 0);
   12133                                 }
   12134                                 ios.width(25);
   12135                                 left(ios);
   12136                                 {
   12137                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12138                                     std::string ex(str, iter.base());
   12139                                     assert(ex == "+0;0*********************");
   12140                                     assert(ios.width() == 0);
   12141                                 }
   12142                                 ios.width(25);
   12143                                 right(ios);
   12144                                 {
   12145                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12146                                     std::string ex(str, iter.base());
   12147                                     assert(ex == "*********************+0;0");
   12148                                     assert(ios.width() == 0);
   12149                                 }
   12150                                 ios.width(25);
   12151                                 internal(ios);
   12152                                 {
   12153                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12154                                     std::string ex(str, iter.base());
   12155                                     assert(ex == "+*********************0;0");
   12156                                     assert(ios.width() == 0);
   12157                                 }
   12158                             }
   12159                         }
   12160                         showpoint(ios);
   12161                         {
   12162                             ios.imbue(lc);
   12163                             {
   12164                                 ios.width(0);
   12165                                 {
   12166                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12167                                     std::string ex(str, iter.base());
   12168                                     assert(ex == "+0.0");
   12169                                     assert(ios.width() == 0);
   12170                                 }
   12171                                 ios.width(25);
   12172                                 left(ios);
   12173                                 {
   12174                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12175                                     std::string ex(str, iter.base());
   12176                                     assert(ex == "+0.0*********************");
   12177                                     assert(ios.width() == 0);
   12178                                 }
   12179                                 ios.width(25);
   12180                                 right(ios);
   12181                                 {
   12182                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12183                                     std::string ex(str, iter.base());
   12184                                     assert(ex == "*********************+0.0");
   12185                                     assert(ios.width() == 0);
   12186                                 }
   12187                                 ios.width(25);
   12188                                 internal(ios);
   12189                                 {
   12190                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12191                                     std::string ex(str, iter.base());
   12192                                     assert(ex == "+*********************0.0");
   12193                                     assert(ios.width() == 0);
   12194                                 }
   12195                             }
   12196                             ios.imbue(lg);
   12197                             {
   12198                                 ios.width(0);
   12199                                 {
   12200                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12201                                     std::string ex(str, iter.base());
   12202                                     assert(ex == "+0;0");
   12203                                     assert(ios.width() == 0);
   12204                                 }
   12205                                 ios.width(25);
   12206                                 left(ios);
   12207                                 {
   12208                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12209                                     std::string ex(str, iter.base());
   12210                                     assert(ex == "+0;0*********************");
   12211                                     assert(ios.width() == 0);
   12212                                 }
   12213                                 ios.width(25);
   12214                                 right(ios);
   12215                                 {
   12216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12217                                     std::string ex(str, iter.base());
   12218                                     assert(ex == "*********************+0;0");
   12219                                     assert(ios.width() == 0);
   12220                                 }
   12221                                 ios.width(25);
   12222                                 internal(ios);
   12223                                 {
   12224                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12225                                     std::string ex(str, iter.base());
   12226                                     assert(ex == "+*********************0;0");
   12227                                     assert(ios.width() == 0);
   12228                                 }
   12229                             }
   12230                         }
   12231                     }
   12232                 }
   12233                 uppercase(ios);
   12234                 {
   12235                     noshowpos(ios);
   12236                     {
   12237                         noshowpoint(ios);
   12238                         {
   12239                             ios.imbue(lc);
   12240                             {
   12241                                 ios.width(0);
   12242                                 {
   12243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12244                                     std::string ex(str, iter.base());
   12245                                     assert(ex == "0.0");
   12246                                     assert(ios.width() == 0);
   12247                                 }
   12248                                 ios.width(25);
   12249                                 left(ios);
   12250                                 {
   12251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12252                                     std::string ex(str, iter.base());
   12253                                     assert(ex == "0.0**********************");
   12254                                     assert(ios.width() == 0);
   12255                                 }
   12256                                 ios.width(25);
   12257                                 right(ios);
   12258                                 {
   12259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12260                                     std::string ex(str, iter.base());
   12261                                     assert(ex == "**********************0.0");
   12262                                     assert(ios.width() == 0);
   12263                                 }
   12264                                 ios.width(25);
   12265                                 internal(ios);
   12266                                 {
   12267                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12268                                     std::string ex(str, iter.base());
   12269                                     assert(ex == "**********************0.0");
   12270                                     assert(ios.width() == 0);
   12271                                 }
   12272                             }
   12273                             ios.imbue(lg);
   12274                             {
   12275                                 ios.width(0);
   12276                                 {
   12277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12278                                     std::string ex(str, iter.base());
   12279                                     assert(ex == "0;0");
   12280                                     assert(ios.width() == 0);
   12281                                 }
   12282                                 ios.width(25);
   12283                                 left(ios);
   12284                                 {
   12285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12286                                     std::string ex(str, iter.base());
   12287                                     assert(ex == "0;0**********************");
   12288                                     assert(ios.width() == 0);
   12289                                 }
   12290                                 ios.width(25);
   12291                                 right(ios);
   12292                                 {
   12293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12294                                     std::string ex(str, iter.base());
   12295                                     assert(ex == "**********************0;0");
   12296                                     assert(ios.width() == 0);
   12297                                 }
   12298                                 ios.width(25);
   12299                                 internal(ios);
   12300                                 {
   12301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12302                                     std::string ex(str, iter.base());
   12303                                     assert(ex == "**********************0;0");
   12304                                     assert(ios.width() == 0);
   12305                                 }
   12306                             }
   12307                         }
   12308                         showpoint(ios);
   12309                         {
   12310                             ios.imbue(lc);
   12311                             {
   12312                                 ios.width(0);
   12313                                 {
   12314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12315                                     std::string ex(str, iter.base());
   12316                                     assert(ex == "0.0");
   12317                                     assert(ios.width() == 0);
   12318                                 }
   12319                                 ios.width(25);
   12320                                 left(ios);
   12321                                 {
   12322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12323                                     std::string ex(str, iter.base());
   12324                                     assert(ex == "0.0**********************");
   12325                                     assert(ios.width() == 0);
   12326                                 }
   12327                                 ios.width(25);
   12328                                 right(ios);
   12329                                 {
   12330                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12331                                     std::string ex(str, iter.base());
   12332                                     assert(ex == "**********************0.0");
   12333                                     assert(ios.width() == 0);
   12334                                 }
   12335                                 ios.width(25);
   12336                                 internal(ios);
   12337                                 {
   12338                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12339                                     std::string ex(str, iter.base());
   12340                                     assert(ex == "**********************0.0");
   12341                                     assert(ios.width() == 0);
   12342                                 }
   12343                             }
   12344                             ios.imbue(lg);
   12345                             {
   12346                                 ios.width(0);
   12347                                 {
   12348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12349                                     std::string ex(str, iter.base());
   12350                                     assert(ex == "0;0");
   12351                                     assert(ios.width() == 0);
   12352                                 }
   12353                                 ios.width(25);
   12354                                 left(ios);
   12355                                 {
   12356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12357                                     std::string ex(str, iter.base());
   12358                                     assert(ex == "0;0**********************");
   12359                                     assert(ios.width() == 0);
   12360                                 }
   12361                                 ios.width(25);
   12362                                 right(ios);
   12363                                 {
   12364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12365                                     std::string ex(str, iter.base());
   12366                                     assert(ex == "**********************0;0");
   12367                                     assert(ios.width() == 0);
   12368                                 }
   12369                                 ios.width(25);
   12370                                 internal(ios);
   12371                                 {
   12372                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12373                                     std::string ex(str, iter.base());
   12374                                     assert(ex == "**********************0;0");
   12375                                     assert(ios.width() == 0);
   12376                                 }
   12377                             }
   12378                         }
   12379                     }
   12380                     showpos(ios);
   12381                     {
   12382                         noshowpoint(ios);
   12383                         {
   12384                             ios.imbue(lc);
   12385                             {
   12386                                 ios.width(0);
   12387                                 {
   12388                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12389                                     std::string ex(str, iter.base());
   12390                                     assert(ex == "+0.0");
   12391                                     assert(ios.width() == 0);
   12392                                 }
   12393                                 ios.width(25);
   12394                                 left(ios);
   12395                                 {
   12396                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12397                                     std::string ex(str, iter.base());
   12398                                     assert(ex == "+0.0*********************");
   12399                                     assert(ios.width() == 0);
   12400                                 }
   12401                                 ios.width(25);
   12402                                 right(ios);
   12403                                 {
   12404                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12405                                     std::string ex(str, iter.base());
   12406                                     assert(ex == "*********************+0.0");
   12407                                     assert(ios.width() == 0);
   12408                                 }
   12409                                 ios.width(25);
   12410                                 internal(ios);
   12411                                 {
   12412                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12413                                     std::string ex(str, iter.base());
   12414                                     assert(ex == "+*********************0.0");
   12415                                     assert(ios.width() == 0);
   12416                                 }
   12417                             }
   12418                             ios.imbue(lg);
   12419                             {
   12420                                 ios.width(0);
   12421                                 {
   12422                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12423                                     std::string ex(str, iter.base());
   12424                                     assert(ex == "+0;0");
   12425                                     assert(ios.width() == 0);
   12426                                 }
   12427                                 ios.width(25);
   12428                                 left(ios);
   12429                                 {
   12430                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12431                                     std::string ex(str, iter.base());
   12432                                     assert(ex == "+0;0*********************");
   12433                                     assert(ios.width() == 0);
   12434                                 }
   12435                                 ios.width(25);
   12436                                 right(ios);
   12437                                 {
   12438                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12439                                     std::string ex(str, iter.base());
   12440                                     assert(ex == "*********************+0;0");
   12441                                     assert(ios.width() == 0);
   12442                                 }
   12443                                 ios.width(25);
   12444                                 internal(ios);
   12445                                 {
   12446                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12447                                     std::string ex(str, iter.base());
   12448                                     assert(ex == "+*********************0;0");
   12449                                     assert(ios.width() == 0);
   12450                                 }
   12451                             }
   12452                         }
   12453                         showpoint(ios);
   12454                         {
   12455                             ios.imbue(lc);
   12456                             {
   12457                                 ios.width(0);
   12458                                 {
   12459                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12460                                     std::string ex(str, iter.base());
   12461                                     assert(ex == "+0.0");
   12462                                     assert(ios.width() == 0);
   12463                                 }
   12464                                 ios.width(25);
   12465                                 left(ios);
   12466                                 {
   12467                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12468                                     std::string ex(str, iter.base());
   12469                                     assert(ex == "+0.0*********************");
   12470                                     assert(ios.width() == 0);
   12471                                 }
   12472                                 ios.width(25);
   12473                                 right(ios);
   12474                                 {
   12475                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12476                                     std::string ex(str, iter.base());
   12477                                     assert(ex == "*********************+0.0");
   12478                                     assert(ios.width() == 0);
   12479                                 }
   12480                                 ios.width(25);
   12481                                 internal(ios);
   12482                                 {
   12483                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12484                                     std::string ex(str, iter.base());
   12485                                     assert(ex == "+*********************0.0");
   12486                                     assert(ios.width() == 0);
   12487                                 }
   12488                             }
   12489                             ios.imbue(lg);
   12490                             {
   12491                                 ios.width(0);
   12492                                 {
   12493                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12494                                     std::string ex(str, iter.base());
   12495                                     assert(ex == "+0;0");
   12496                                     assert(ios.width() == 0);
   12497                                 }
   12498                                 ios.width(25);
   12499                                 left(ios);
   12500                                 {
   12501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12502                                     std::string ex(str, iter.base());
   12503                                     assert(ex == "+0;0*********************");
   12504                                     assert(ios.width() == 0);
   12505                                 }
   12506                                 ios.width(25);
   12507                                 right(ios);
   12508                                 {
   12509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12510                                     std::string ex(str, iter.base());
   12511                                     assert(ex == "*********************+0;0");
   12512                                     assert(ios.width() == 0);
   12513                                 }
   12514                                 ios.width(25);
   12515                                 internal(ios);
   12516                                 {
   12517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12518                                     std::string ex(str, iter.base());
   12519                                     assert(ex == "+*********************0;0");
   12520                                     assert(ios.width() == 0);
   12521                                 }
   12522                             }
   12523                         }
   12524                     }
   12525                 }
   12526             }
   12527             ios.precision(6);
   12528             {
   12529                 nouppercase(ios);
   12530                 {
   12531                     noshowpos(ios);
   12532                     {
   12533                         noshowpoint(ios);
   12534                         {
   12535                             ios.imbue(lc);
   12536                             {
   12537                                 ios.width(0);
   12538                                 {
   12539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12540                                     std::string ex(str, iter.base());
   12541                                     assert(ex == "0.000000");
   12542                                     assert(ios.width() == 0);
   12543                                 }
   12544                                 ios.width(25);
   12545                                 left(ios);
   12546                                 {
   12547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12548                                     std::string ex(str, iter.base());
   12549                                     assert(ex == "0.000000*****************");
   12550                                     assert(ios.width() == 0);
   12551                                 }
   12552                                 ios.width(25);
   12553                                 right(ios);
   12554                                 {
   12555                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12556                                     std::string ex(str, iter.base());
   12557                                     assert(ex == "*****************0.000000");
   12558                                     assert(ios.width() == 0);
   12559                                 }
   12560                                 ios.width(25);
   12561                                 internal(ios);
   12562                                 {
   12563                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12564                                     std::string ex(str, iter.base());
   12565                                     assert(ex == "*****************0.000000");
   12566                                     assert(ios.width() == 0);
   12567                                 }
   12568                             }
   12569                             ios.imbue(lg);
   12570                             {
   12571                                 ios.width(0);
   12572                                 {
   12573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12574                                     std::string ex(str, iter.base());
   12575                                     assert(ex == "0;000000");
   12576                                     assert(ios.width() == 0);
   12577                                 }
   12578                                 ios.width(25);
   12579                                 left(ios);
   12580                                 {
   12581                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12582                                     std::string ex(str, iter.base());
   12583                                     assert(ex == "0;000000*****************");
   12584                                     assert(ios.width() == 0);
   12585                                 }
   12586                                 ios.width(25);
   12587                                 right(ios);
   12588                                 {
   12589                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12590                                     std::string ex(str, iter.base());
   12591                                     assert(ex == "*****************0;000000");
   12592                                     assert(ios.width() == 0);
   12593                                 }
   12594                                 ios.width(25);
   12595                                 internal(ios);
   12596                                 {
   12597                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12598                                     std::string ex(str, iter.base());
   12599                                     assert(ex == "*****************0;000000");
   12600                                     assert(ios.width() == 0);
   12601                                 }
   12602                             }
   12603                         }
   12604                         showpoint(ios);
   12605                         {
   12606                             ios.imbue(lc);
   12607                             {
   12608                                 ios.width(0);
   12609                                 {
   12610                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12611                                     std::string ex(str, iter.base());
   12612                                     assert(ex == "0.000000");
   12613                                     assert(ios.width() == 0);
   12614                                 }
   12615                                 ios.width(25);
   12616                                 left(ios);
   12617                                 {
   12618                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12619                                     std::string ex(str, iter.base());
   12620                                     assert(ex == "0.000000*****************");
   12621                                     assert(ios.width() == 0);
   12622                                 }
   12623                                 ios.width(25);
   12624                                 right(ios);
   12625                                 {
   12626                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12627                                     std::string ex(str, iter.base());
   12628                                     assert(ex == "*****************0.000000");
   12629                                     assert(ios.width() == 0);
   12630                                 }
   12631                                 ios.width(25);
   12632                                 internal(ios);
   12633                                 {
   12634                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12635                                     std::string ex(str, iter.base());
   12636                                     assert(ex == "*****************0.000000");
   12637                                     assert(ios.width() == 0);
   12638                                 }
   12639                             }
   12640                             ios.imbue(lg);
   12641                             {
   12642                                 ios.width(0);
   12643                                 {
   12644                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12645                                     std::string ex(str, iter.base());
   12646                                     assert(ex == "0;000000");
   12647                                     assert(ios.width() == 0);
   12648                                 }
   12649                                 ios.width(25);
   12650                                 left(ios);
   12651                                 {
   12652                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12653                                     std::string ex(str, iter.base());
   12654                                     assert(ex == "0;000000*****************");
   12655                                     assert(ios.width() == 0);
   12656                                 }
   12657                                 ios.width(25);
   12658                                 right(ios);
   12659                                 {
   12660                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12661                                     std::string ex(str, iter.base());
   12662                                     assert(ex == "*****************0;000000");
   12663                                     assert(ios.width() == 0);
   12664                                 }
   12665                                 ios.width(25);
   12666                                 internal(ios);
   12667                                 {
   12668                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12669                                     std::string ex(str, iter.base());
   12670                                     assert(ex == "*****************0;000000");
   12671                                     assert(ios.width() == 0);
   12672                                 }
   12673                             }
   12674                         }
   12675                     }
   12676                     showpos(ios);
   12677                     {
   12678                         noshowpoint(ios);
   12679                         {
   12680                             ios.imbue(lc);
   12681                             {
   12682                                 ios.width(0);
   12683                                 {
   12684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12685                                     std::string ex(str, iter.base());
   12686                                     assert(ex == "+0.000000");
   12687                                     assert(ios.width() == 0);
   12688                                 }
   12689                                 ios.width(25);
   12690                                 left(ios);
   12691                                 {
   12692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12693                                     std::string ex(str, iter.base());
   12694                                     assert(ex == "+0.000000****************");
   12695                                     assert(ios.width() == 0);
   12696                                 }
   12697                                 ios.width(25);
   12698                                 right(ios);
   12699                                 {
   12700                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12701                                     std::string ex(str, iter.base());
   12702                                     assert(ex == "****************+0.000000");
   12703                                     assert(ios.width() == 0);
   12704                                 }
   12705                                 ios.width(25);
   12706                                 internal(ios);
   12707                                 {
   12708                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12709                                     std::string ex(str, iter.base());
   12710                                     assert(ex == "+****************0.000000");
   12711                                     assert(ios.width() == 0);
   12712                                 }
   12713                             }
   12714                             ios.imbue(lg);
   12715                             {
   12716                                 ios.width(0);
   12717                                 {
   12718                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12719                                     std::string ex(str, iter.base());
   12720                                     assert(ex == "+0;000000");
   12721                                     assert(ios.width() == 0);
   12722                                 }
   12723                                 ios.width(25);
   12724                                 left(ios);
   12725                                 {
   12726                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12727                                     std::string ex(str, iter.base());
   12728                                     assert(ex == "+0;000000****************");
   12729                                     assert(ios.width() == 0);
   12730                                 }
   12731                                 ios.width(25);
   12732                                 right(ios);
   12733                                 {
   12734                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12735                                     std::string ex(str, iter.base());
   12736                                     assert(ex == "****************+0;000000");
   12737                                     assert(ios.width() == 0);
   12738                                 }
   12739                                 ios.width(25);
   12740                                 internal(ios);
   12741                                 {
   12742                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12743                                     std::string ex(str, iter.base());
   12744                                     assert(ex == "+****************0;000000");
   12745                                     assert(ios.width() == 0);
   12746                                 }
   12747                             }
   12748                         }
   12749                         showpoint(ios);
   12750                         {
   12751                             ios.imbue(lc);
   12752                             {
   12753                                 ios.width(0);
   12754                                 {
   12755                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12756                                     std::string ex(str, iter.base());
   12757                                     assert(ex == "+0.000000");
   12758                                     assert(ios.width() == 0);
   12759                                 }
   12760                                 ios.width(25);
   12761                                 left(ios);
   12762                                 {
   12763                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12764                                     std::string ex(str, iter.base());
   12765                                     assert(ex == "+0.000000****************");
   12766                                     assert(ios.width() == 0);
   12767                                 }
   12768                                 ios.width(25);
   12769                                 right(ios);
   12770                                 {
   12771                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12772                                     std::string ex(str, iter.base());
   12773                                     assert(ex == "****************+0.000000");
   12774                                     assert(ios.width() == 0);
   12775                                 }
   12776                                 ios.width(25);
   12777                                 internal(ios);
   12778                                 {
   12779                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12780                                     std::string ex(str, iter.base());
   12781                                     assert(ex == "+****************0.000000");
   12782                                     assert(ios.width() == 0);
   12783                                 }
   12784                             }
   12785                             ios.imbue(lg);
   12786                             {
   12787                                 ios.width(0);
   12788                                 {
   12789                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12790                                     std::string ex(str, iter.base());
   12791                                     assert(ex == "+0;000000");
   12792                                     assert(ios.width() == 0);
   12793                                 }
   12794                                 ios.width(25);
   12795                                 left(ios);
   12796                                 {
   12797                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12798                                     std::string ex(str, iter.base());
   12799                                     assert(ex == "+0;000000****************");
   12800                                     assert(ios.width() == 0);
   12801                                 }
   12802                                 ios.width(25);
   12803                                 right(ios);
   12804                                 {
   12805                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12806                                     std::string ex(str, iter.base());
   12807                                     assert(ex == "****************+0;000000");
   12808                                     assert(ios.width() == 0);
   12809                                 }
   12810                                 ios.width(25);
   12811                                 internal(ios);
   12812                                 {
   12813                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12814                                     std::string ex(str, iter.base());
   12815                                     assert(ex == "+****************0;000000");
   12816                                     assert(ios.width() == 0);
   12817                                 }
   12818                             }
   12819                         }
   12820                     }
   12821                 }
   12822                 uppercase(ios);
   12823                 {
   12824                     noshowpos(ios);
   12825                     {
   12826                         noshowpoint(ios);
   12827                         {
   12828                             ios.imbue(lc);
   12829                             {
   12830                                 ios.width(0);
   12831                                 {
   12832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12833                                     std::string ex(str, iter.base());
   12834                                     assert(ex == "0.000000");
   12835                                     assert(ios.width() == 0);
   12836                                 }
   12837                                 ios.width(25);
   12838                                 left(ios);
   12839                                 {
   12840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12841                                     std::string ex(str, iter.base());
   12842                                     assert(ex == "0.000000*****************");
   12843                                     assert(ios.width() == 0);
   12844                                 }
   12845                                 ios.width(25);
   12846                                 right(ios);
   12847                                 {
   12848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12849                                     std::string ex(str, iter.base());
   12850                                     assert(ex == "*****************0.000000");
   12851                                     assert(ios.width() == 0);
   12852                                 }
   12853                                 ios.width(25);
   12854                                 internal(ios);
   12855                                 {
   12856                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12857                                     std::string ex(str, iter.base());
   12858                                     assert(ex == "*****************0.000000");
   12859                                     assert(ios.width() == 0);
   12860                                 }
   12861                             }
   12862                             ios.imbue(lg);
   12863                             {
   12864                                 ios.width(0);
   12865                                 {
   12866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12867                                     std::string ex(str, iter.base());
   12868                                     assert(ex == "0;000000");
   12869                                     assert(ios.width() == 0);
   12870                                 }
   12871                                 ios.width(25);
   12872                                 left(ios);
   12873                                 {
   12874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12875                                     std::string ex(str, iter.base());
   12876                                     assert(ex == "0;000000*****************");
   12877                                     assert(ios.width() == 0);
   12878                                 }
   12879                                 ios.width(25);
   12880                                 right(ios);
   12881                                 {
   12882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12883                                     std::string ex(str, iter.base());
   12884                                     assert(ex == "*****************0;000000");
   12885                                     assert(ios.width() == 0);
   12886                                 }
   12887                                 ios.width(25);
   12888                                 internal(ios);
   12889                                 {
   12890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12891                                     std::string ex(str, iter.base());
   12892                                     assert(ex == "*****************0;000000");
   12893                                     assert(ios.width() == 0);
   12894                                 }
   12895                             }
   12896                         }
   12897                         showpoint(ios);
   12898                         {
   12899                             ios.imbue(lc);
   12900                             {
   12901                                 ios.width(0);
   12902                                 {
   12903                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12904                                     std::string ex(str, iter.base());
   12905                                     assert(ex == "0.000000");
   12906                                     assert(ios.width() == 0);
   12907                                 }
   12908                                 ios.width(25);
   12909                                 left(ios);
   12910                                 {
   12911                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12912                                     std::string ex(str, iter.base());
   12913                                     assert(ex == "0.000000*****************");
   12914                                     assert(ios.width() == 0);
   12915                                 }
   12916                                 ios.width(25);
   12917                                 right(ios);
   12918                                 {
   12919                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12920                                     std::string ex(str, iter.base());
   12921                                     assert(ex == "*****************0.000000");
   12922                                     assert(ios.width() == 0);
   12923                                 }
   12924                                 ios.width(25);
   12925                                 internal(ios);
   12926                                 {
   12927                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12928                                     std::string ex(str, iter.base());
   12929                                     assert(ex == "*****************0.000000");
   12930                                     assert(ios.width() == 0);
   12931                                 }
   12932                             }
   12933                             ios.imbue(lg);
   12934                             {
   12935                                 ios.width(0);
   12936                                 {
   12937                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12938                                     std::string ex(str, iter.base());
   12939                                     assert(ex == "0;000000");
   12940                                     assert(ios.width() == 0);
   12941                                 }
   12942                                 ios.width(25);
   12943                                 left(ios);
   12944                                 {
   12945                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12946                                     std::string ex(str, iter.base());
   12947                                     assert(ex == "0;000000*****************");
   12948                                     assert(ios.width() == 0);
   12949                                 }
   12950                                 ios.width(25);
   12951                                 right(ios);
   12952                                 {
   12953                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12954                                     std::string ex(str, iter.base());
   12955                                     assert(ex == "*****************0;000000");
   12956                                     assert(ios.width() == 0);
   12957                                 }
   12958                                 ios.width(25);
   12959                                 internal(ios);
   12960                                 {
   12961                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12962                                     std::string ex(str, iter.base());
   12963                                     assert(ex == "*****************0;000000");
   12964                                     assert(ios.width() == 0);
   12965                                 }
   12966                             }
   12967                         }
   12968                     }
   12969                     showpos(ios);
   12970                     {
   12971                         noshowpoint(ios);
   12972                         {
   12973                             ios.imbue(lc);
   12974                             {
   12975                                 ios.width(0);
   12976                                 {
   12977                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12978                                     std::string ex(str, iter.base());
   12979                                     assert(ex == "+0.000000");
   12980                                     assert(ios.width() == 0);
   12981                                 }
   12982                                 ios.width(25);
   12983                                 left(ios);
   12984                                 {
   12985                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12986                                     std::string ex(str, iter.base());
   12987                                     assert(ex == "+0.000000****************");
   12988                                     assert(ios.width() == 0);
   12989                                 }
   12990                                 ios.width(25);
   12991                                 right(ios);
   12992                                 {
   12993                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   12994                                     std::string ex(str, iter.base());
   12995                                     assert(ex == "****************+0.000000");
   12996                                     assert(ios.width() == 0);
   12997                                 }
   12998                                 ios.width(25);
   12999                                 internal(ios);
   13000                                 {
   13001                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13002                                     std::string ex(str, iter.base());
   13003                                     assert(ex == "+****************0.000000");
   13004                                     assert(ios.width() == 0);
   13005                                 }
   13006                             }
   13007                             ios.imbue(lg);
   13008                             {
   13009                                 ios.width(0);
   13010                                 {
   13011                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13012                                     std::string ex(str, iter.base());
   13013                                     assert(ex == "+0;000000");
   13014                                     assert(ios.width() == 0);
   13015                                 }
   13016                                 ios.width(25);
   13017                                 left(ios);
   13018                                 {
   13019                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13020                                     std::string ex(str, iter.base());
   13021                                     assert(ex == "+0;000000****************");
   13022                                     assert(ios.width() == 0);
   13023                                 }
   13024                                 ios.width(25);
   13025                                 right(ios);
   13026                                 {
   13027                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13028                                     std::string ex(str, iter.base());
   13029                                     assert(ex == "****************+0;000000");
   13030                                     assert(ios.width() == 0);
   13031                                 }
   13032                                 ios.width(25);
   13033                                 internal(ios);
   13034                                 {
   13035                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13036                                     std::string ex(str, iter.base());
   13037                                     assert(ex == "+****************0;000000");
   13038                                     assert(ios.width() == 0);
   13039                                 }
   13040                             }
   13041                         }
   13042                         showpoint(ios);
   13043                         {
   13044                             ios.imbue(lc);
   13045                             {
   13046                                 ios.width(0);
   13047                                 {
   13048                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13049                                     std::string ex(str, iter.base());
   13050                                     assert(ex == "+0.000000");
   13051                                     assert(ios.width() == 0);
   13052                                 }
   13053                                 ios.width(25);
   13054                                 left(ios);
   13055                                 {
   13056                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13057                                     std::string ex(str, iter.base());
   13058                                     assert(ex == "+0.000000****************");
   13059                                     assert(ios.width() == 0);
   13060                                 }
   13061                                 ios.width(25);
   13062                                 right(ios);
   13063                                 {
   13064                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13065                                     std::string ex(str, iter.base());
   13066                                     assert(ex == "****************+0.000000");
   13067                                     assert(ios.width() == 0);
   13068                                 }
   13069                                 ios.width(25);
   13070                                 internal(ios);
   13071                                 {
   13072                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13073                                     std::string ex(str, iter.base());
   13074                                     assert(ex == "+****************0.000000");
   13075                                     assert(ios.width() == 0);
   13076                                 }
   13077                             }
   13078                             ios.imbue(lg);
   13079                             {
   13080                                 ios.width(0);
   13081                                 {
   13082                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13083                                     std::string ex(str, iter.base());
   13084                                     assert(ex == "+0;000000");
   13085                                     assert(ios.width() == 0);
   13086                                 }
   13087                                 ios.width(25);
   13088                                 left(ios);
   13089                                 {
   13090                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13091                                     std::string ex(str, iter.base());
   13092                                     assert(ex == "+0;000000****************");
   13093                                     assert(ios.width() == 0);
   13094                                 }
   13095                                 ios.width(25);
   13096                                 right(ios);
   13097                                 {
   13098                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13099                                     std::string ex(str, iter.base());
   13100                                     assert(ex == "****************+0;000000");
   13101                                     assert(ios.width() == 0);
   13102                                 }
   13103                                 ios.width(25);
   13104                                 internal(ios);
   13105                                 {
   13106                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13107                                     std::string ex(str, iter.base());
   13108                                     assert(ex == "+****************0;000000");
   13109                                     assert(ios.width() == 0);
   13110                                 }
   13111                             }
   13112                         }
   13113                     }
   13114                 }
   13115             }
   13116             ios.precision(16);
   13117             {
   13118                 nouppercase(ios);
   13119                 {
   13120                     noshowpos(ios);
   13121                     {
   13122                         noshowpoint(ios);
   13123                         {
   13124                             ios.imbue(lc);
   13125                             {
   13126                                 ios.width(0);
   13127                                 {
   13128                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13129                                     std::string ex(str, iter.base());
   13130                                     assert(ex == "0.0000000000000000");
   13131                                     assert(ios.width() == 0);
   13132                                 }
   13133                                 ios.width(25);
   13134                                 left(ios);
   13135                                 {
   13136                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13137                                     std::string ex(str, iter.base());
   13138                                     assert(ex == "0.0000000000000000*******");
   13139                                     assert(ios.width() == 0);
   13140                                 }
   13141                                 ios.width(25);
   13142                                 right(ios);
   13143                                 {
   13144                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13145                                     std::string ex(str, iter.base());
   13146                                     assert(ex == "*******0.0000000000000000");
   13147                                     assert(ios.width() == 0);
   13148                                 }
   13149                                 ios.width(25);
   13150                                 internal(ios);
   13151                                 {
   13152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13153                                     std::string ex(str, iter.base());
   13154                                     assert(ex == "*******0.0000000000000000");
   13155                                     assert(ios.width() == 0);
   13156                                 }
   13157                             }
   13158                             ios.imbue(lg);
   13159                             {
   13160                                 ios.width(0);
   13161                                 {
   13162                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13163                                     std::string ex(str, iter.base());
   13164                                     assert(ex == "0;0000000000000000");
   13165                                     assert(ios.width() == 0);
   13166                                 }
   13167                                 ios.width(25);
   13168                                 left(ios);
   13169                                 {
   13170                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13171                                     std::string ex(str, iter.base());
   13172                                     assert(ex == "0;0000000000000000*******");
   13173                                     assert(ios.width() == 0);
   13174                                 }
   13175                                 ios.width(25);
   13176                                 right(ios);
   13177                                 {
   13178                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13179                                     std::string ex(str, iter.base());
   13180                                     assert(ex == "*******0;0000000000000000");
   13181                                     assert(ios.width() == 0);
   13182                                 }
   13183                                 ios.width(25);
   13184                                 internal(ios);
   13185                                 {
   13186                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13187                                     std::string ex(str, iter.base());
   13188                                     assert(ex == "*******0;0000000000000000");
   13189                                     assert(ios.width() == 0);
   13190                                 }
   13191                             }
   13192                         }
   13193                         showpoint(ios);
   13194                         {
   13195                             ios.imbue(lc);
   13196                             {
   13197                                 ios.width(0);
   13198                                 {
   13199                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13200                                     std::string ex(str, iter.base());
   13201                                     assert(ex == "0.0000000000000000");
   13202                                     assert(ios.width() == 0);
   13203                                 }
   13204                                 ios.width(25);
   13205                                 left(ios);
   13206                                 {
   13207                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13208                                     std::string ex(str, iter.base());
   13209                                     assert(ex == "0.0000000000000000*******");
   13210                                     assert(ios.width() == 0);
   13211                                 }
   13212                                 ios.width(25);
   13213                                 right(ios);
   13214                                 {
   13215                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13216                                     std::string ex(str, iter.base());
   13217                                     assert(ex == "*******0.0000000000000000");
   13218                                     assert(ios.width() == 0);
   13219                                 }
   13220                                 ios.width(25);
   13221                                 internal(ios);
   13222                                 {
   13223                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13224                                     std::string ex(str, iter.base());
   13225                                     assert(ex == "*******0.0000000000000000");
   13226                                     assert(ios.width() == 0);
   13227                                 }
   13228                             }
   13229                             ios.imbue(lg);
   13230                             {
   13231                                 ios.width(0);
   13232                                 {
   13233                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13234                                     std::string ex(str, iter.base());
   13235                                     assert(ex == "0;0000000000000000");
   13236                                     assert(ios.width() == 0);
   13237                                 }
   13238                                 ios.width(25);
   13239                                 left(ios);
   13240                                 {
   13241                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13242                                     std::string ex(str, iter.base());
   13243                                     assert(ex == "0;0000000000000000*******");
   13244                                     assert(ios.width() == 0);
   13245                                 }
   13246                                 ios.width(25);
   13247                                 right(ios);
   13248                                 {
   13249                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13250                                     std::string ex(str, iter.base());
   13251                                     assert(ex == "*******0;0000000000000000");
   13252                                     assert(ios.width() == 0);
   13253                                 }
   13254                                 ios.width(25);
   13255                                 internal(ios);
   13256                                 {
   13257                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13258                                     std::string ex(str, iter.base());
   13259                                     assert(ex == "*******0;0000000000000000");
   13260                                     assert(ios.width() == 0);
   13261                                 }
   13262                             }
   13263                         }
   13264                     }
   13265                     showpos(ios);
   13266                     {
   13267                         noshowpoint(ios);
   13268                         {
   13269                             ios.imbue(lc);
   13270                             {
   13271                                 ios.width(0);
   13272                                 {
   13273                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13274                                     std::string ex(str, iter.base());
   13275                                     assert(ex == "+0.0000000000000000");
   13276                                     assert(ios.width() == 0);
   13277                                 }
   13278                                 ios.width(25);
   13279                                 left(ios);
   13280                                 {
   13281                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13282                                     std::string ex(str, iter.base());
   13283                                     assert(ex == "+0.0000000000000000******");
   13284                                     assert(ios.width() == 0);
   13285                                 }
   13286                                 ios.width(25);
   13287                                 right(ios);
   13288                                 {
   13289                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13290                                     std::string ex(str, iter.base());
   13291                                     assert(ex == "******+0.0000000000000000");
   13292                                     assert(ios.width() == 0);
   13293                                 }
   13294                                 ios.width(25);
   13295                                 internal(ios);
   13296                                 {
   13297                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13298                                     std::string ex(str, iter.base());
   13299                                     assert(ex == "+******0.0000000000000000");
   13300                                     assert(ios.width() == 0);
   13301                                 }
   13302                             }
   13303                             ios.imbue(lg);
   13304                             {
   13305                                 ios.width(0);
   13306                                 {
   13307                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13308                                     std::string ex(str, iter.base());
   13309                                     assert(ex == "+0;0000000000000000");
   13310                                     assert(ios.width() == 0);
   13311                                 }
   13312                                 ios.width(25);
   13313                                 left(ios);
   13314                                 {
   13315                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13316                                     std::string ex(str, iter.base());
   13317                                     assert(ex == "+0;0000000000000000******");
   13318                                     assert(ios.width() == 0);
   13319                                 }
   13320                                 ios.width(25);
   13321                                 right(ios);
   13322                                 {
   13323                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13324                                     std::string ex(str, iter.base());
   13325                                     assert(ex == "******+0;0000000000000000");
   13326                                     assert(ios.width() == 0);
   13327                                 }
   13328                                 ios.width(25);
   13329                                 internal(ios);
   13330                                 {
   13331                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13332                                     std::string ex(str, iter.base());
   13333                                     assert(ex == "+******0;0000000000000000");
   13334                                     assert(ios.width() == 0);
   13335                                 }
   13336                             }
   13337                         }
   13338                         showpoint(ios);
   13339                         {
   13340                             ios.imbue(lc);
   13341                             {
   13342                                 ios.width(0);
   13343                                 {
   13344                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13345                                     std::string ex(str, iter.base());
   13346                                     assert(ex == "+0.0000000000000000");
   13347                                     assert(ios.width() == 0);
   13348                                 }
   13349                                 ios.width(25);
   13350                                 left(ios);
   13351                                 {
   13352                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13353                                     std::string ex(str, iter.base());
   13354                                     assert(ex == "+0.0000000000000000******");
   13355                                     assert(ios.width() == 0);
   13356                                 }
   13357                                 ios.width(25);
   13358                                 right(ios);
   13359                                 {
   13360                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13361                                     std::string ex(str, iter.base());
   13362                                     assert(ex == "******+0.0000000000000000");
   13363                                     assert(ios.width() == 0);
   13364                                 }
   13365                                 ios.width(25);
   13366                                 internal(ios);
   13367                                 {
   13368                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13369                                     std::string ex(str, iter.base());
   13370                                     assert(ex == "+******0.0000000000000000");
   13371                                     assert(ios.width() == 0);
   13372                                 }
   13373                             }
   13374                             ios.imbue(lg);
   13375                             {
   13376                                 ios.width(0);
   13377                                 {
   13378                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13379                                     std::string ex(str, iter.base());
   13380                                     assert(ex == "+0;0000000000000000");
   13381                                     assert(ios.width() == 0);
   13382                                 }
   13383                                 ios.width(25);
   13384                                 left(ios);
   13385                                 {
   13386                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13387                                     std::string ex(str, iter.base());
   13388                                     assert(ex == "+0;0000000000000000******");
   13389                                     assert(ios.width() == 0);
   13390                                 }
   13391                                 ios.width(25);
   13392                                 right(ios);
   13393                                 {
   13394                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13395                                     std::string ex(str, iter.base());
   13396                                     assert(ex == "******+0;0000000000000000");
   13397                                     assert(ios.width() == 0);
   13398                                 }
   13399                                 ios.width(25);
   13400                                 internal(ios);
   13401                                 {
   13402                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13403                                     std::string ex(str, iter.base());
   13404                                     assert(ex == "+******0;0000000000000000");
   13405                                     assert(ios.width() == 0);
   13406                                 }
   13407                             }
   13408                         }
   13409                     }
   13410                 }
   13411                 uppercase(ios);
   13412                 {
   13413                     noshowpos(ios);
   13414                     {
   13415                         noshowpoint(ios);
   13416                         {
   13417                             ios.imbue(lc);
   13418                             {
   13419                                 ios.width(0);
   13420                                 {
   13421                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13422                                     std::string ex(str, iter.base());
   13423                                     assert(ex == "0.0000000000000000");
   13424                                     assert(ios.width() == 0);
   13425                                 }
   13426                                 ios.width(25);
   13427                                 left(ios);
   13428                                 {
   13429                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13430                                     std::string ex(str, iter.base());
   13431                                     assert(ex == "0.0000000000000000*******");
   13432                                     assert(ios.width() == 0);
   13433                                 }
   13434                                 ios.width(25);
   13435                                 right(ios);
   13436                                 {
   13437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13438                                     std::string ex(str, iter.base());
   13439                                     assert(ex == "*******0.0000000000000000");
   13440                                     assert(ios.width() == 0);
   13441                                 }
   13442                                 ios.width(25);
   13443                                 internal(ios);
   13444                                 {
   13445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13446                                     std::string ex(str, iter.base());
   13447                                     assert(ex == "*******0.0000000000000000");
   13448                                     assert(ios.width() == 0);
   13449                                 }
   13450                             }
   13451                             ios.imbue(lg);
   13452                             {
   13453                                 ios.width(0);
   13454                                 {
   13455                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13456                                     std::string ex(str, iter.base());
   13457                                     assert(ex == "0;0000000000000000");
   13458                                     assert(ios.width() == 0);
   13459                                 }
   13460                                 ios.width(25);
   13461                                 left(ios);
   13462                                 {
   13463                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13464                                     std::string ex(str, iter.base());
   13465                                     assert(ex == "0;0000000000000000*******");
   13466                                     assert(ios.width() == 0);
   13467                                 }
   13468                                 ios.width(25);
   13469                                 right(ios);
   13470                                 {
   13471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13472                                     std::string ex(str, iter.base());
   13473                                     assert(ex == "*******0;0000000000000000");
   13474                                     assert(ios.width() == 0);
   13475                                 }
   13476                                 ios.width(25);
   13477                                 internal(ios);
   13478                                 {
   13479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13480                                     std::string ex(str, iter.base());
   13481                                     assert(ex == "*******0;0000000000000000");
   13482                                     assert(ios.width() == 0);
   13483                                 }
   13484                             }
   13485                         }
   13486                         showpoint(ios);
   13487                         {
   13488                             ios.imbue(lc);
   13489                             {
   13490                                 ios.width(0);
   13491                                 {
   13492                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13493                                     std::string ex(str, iter.base());
   13494                                     assert(ex == "0.0000000000000000");
   13495                                     assert(ios.width() == 0);
   13496                                 }
   13497                                 ios.width(25);
   13498                                 left(ios);
   13499                                 {
   13500                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13501                                     std::string ex(str, iter.base());
   13502                                     assert(ex == "0.0000000000000000*******");
   13503                                     assert(ios.width() == 0);
   13504                                 }
   13505                                 ios.width(25);
   13506                                 right(ios);
   13507                                 {
   13508                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13509                                     std::string ex(str, iter.base());
   13510                                     assert(ex == "*******0.0000000000000000");
   13511                                     assert(ios.width() == 0);
   13512                                 }
   13513                                 ios.width(25);
   13514                                 internal(ios);
   13515                                 {
   13516                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13517                                     std::string ex(str, iter.base());
   13518                                     assert(ex == "*******0.0000000000000000");
   13519                                     assert(ios.width() == 0);
   13520                                 }
   13521                             }
   13522                             ios.imbue(lg);
   13523                             {
   13524                                 ios.width(0);
   13525                                 {
   13526                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13527                                     std::string ex(str, iter.base());
   13528                                     assert(ex == "0;0000000000000000");
   13529                                     assert(ios.width() == 0);
   13530                                 }
   13531                                 ios.width(25);
   13532                                 left(ios);
   13533                                 {
   13534                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13535                                     std::string ex(str, iter.base());
   13536                                     assert(ex == "0;0000000000000000*******");
   13537                                     assert(ios.width() == 0);
   13538                                 }
   13539                                 ios.width(25);
   13540                                 right(ios);
   13541                                 {
   13542                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13543                                     std::string ex(str, iter.base());
   13544                                     assert(ex == "*******0;0000000000000000");
   13545                                     assert(ios.width() == 0);
   13546                                 }
   13547                                 ios.width(25);
   13548                                 internal(ios);
   13549                                 {
   13550                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13551                                     std::string ex(str, iter.base());
   13552                                     assert(ex == "*******0;0000000000000000");
   13553                                     assert(ios.width() == 0);
   13554                                 }
   13555                             }
   13556                         }
   13557                     }
   13558                     showpos(ios);
   13559                     {
   13560                         noshowpoint(ios);
   13561                         {
   13562                             ios.imbue(lc);
   13563                             {
   13564                                 ios.width(0);
   13565                                 {
   13566                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13567                                     std::string ex(str, iter.base());
   13568                                     assert(ex == "+0.0000000000000000");
   13569                                     assert(ios.width() == 0);
   13570                                 }
   13571                                 ios.width(25);
   13572                                 left(ios);
   13573                                 {
   13574                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13575                                     std::string ex(str, iter.base());
   13576                                     assert(ex == "+0.0000000000000000******");
   13577                                     assert(ios.width() == 0);
   13578                                 }
   13579                                 ios.width(25);
   13580                                 right(ios);
   13581                                 {
   13582                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13583                                     std::string ex(str, iter.base());
   13584                                     assert(ex == "******+0.0000000000000000");
   13585                                     assert(ios.width() == 0);
   13586                                 }
   13587                                 ios.width(25);
   13588                                 internal(ios);
   13589                                 {
   13590                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13591                                     std::string ex(str, iter.base());
   13592                                     assert(ex == "+******0.0000000000000000");
   13593                                     assert(ios.width() == 0);
   13594                                 }
   13595                             }
   13596                             ios.imbue(lg);
   13597                             {
   13598                                 ios.width(0);
   13599                                 {
   13600                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13601                                     std::string ex(str, iter.base());
   13602                                     assert(ex == "+0;0000000000000000");
   13603                                     assert(ios.width() == 0);
   13604                                 }
   13605                                 ios.width(25);
   13606                                 left(ios);
   13607                                 {
   13608                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13609                                     std::string ex(str, iter.base());
   13610                                     assert(ex == "+0;0000000000000000******");
   13611                                     assert(ios.width() == 0);
   13612                                 }
   13613                                 ios.width(25);
   13614                                 right(ios);
   13615                                 {
   13616                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13617                                     std::string ex(str, iter.base());
   13618                                     assert(ex == "******+0;0000000000000000");
   13619                                     assert(ios.width() == 0);
   13620                                 }
   13621                                 ios.width(25);
   13622                                 internal(ios);
   13623                                 {
   13624                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13625                                     std::string ex(str, iter.base());
   13626                                     assert(ex == "+******0;0000000000000000");
   13627                                     assert(ios.width() == 0);
   13628                                 }
   13629                             }
   13630                         }
   13631                         showpoint(ios);
   13632                         {
   13633                             ios.imbue(lc);
   13634                             {
   13635                                 ios.width(0);
   13636                                 {
   13637                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13638                                     std::string ex(str, iter.base());
   13639                                     assert(ex == "+0.0000000000000000");
   13640                                     assert(ios.width() == 0);
   13641                                 }
   13642                                 ios.width(25);
   13643                                 left(ios);
   13644                                 {
   13645                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13646                                     std::string ex(str, iter.base());
   13647                                     assert(ex == "+0.0000000000000000******");
   13648                                     assert(ios.width() == 0);
   13649                                 }
   13650                                 ios.width(25);
   13651                                 right(ios);
   13652                                 {
   13653                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13654                                     std::string ex(str, iter.base());
   13655                                     assert(ex == "******+0.0000000000000000");
   13656                                     assert(ios.width() == 0);
   13657                                 }
   13658                                 ios.width(25);
   13659                                 internal(ios);
   13660                                 {
   13661                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13662                                     std::string ex(str, iter.base());
   13663                                     assert(ex == "+******0.0000000000000000");
   13664                                     assert(ios.width() == 0);
   13665                                 }
   13666                             }
   13667                             ios.imbue(lg);
   13668                             {
   13669                                 ios.width(0);
   13670                                 {
   13671                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13672                                     std::string ex(str, iter.base());
   13673                                     assert(ex == "+0;0000000000000000");
   13674                                     assert(ios.width() == 0);
   13675                                 }
   13676                                 ios.width(25);
   13677                                 left(ios);
   13678                                 {
   13679                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13680                                     std::string ex(str, iter.base());
   13681                                     assert(ex == "+0;0000000000000000******");
   13682                                     assert(ios.width() == 0);
   13683                                 }
   13684                                 ios.width(25);
   13685                                 right(ios);
   13686                                 {
   13687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13688                                     std::string ex(str, iter.base());
   13689                                     assert(ex == "******+0;0000000000000000");
   13690                                     assert(ios.width() == 0);
   13691                                 }
   13692                                 ios.width(25);
   13693                                 internal(ios);
   13694                                 {
   13695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13696                                     std::string ex(str, iter.base());
   13697                                     assert(ex == "+******0;0000000000000000");
   13698                                     assert(ios.width() == 0);
   13699                                 }
   13700                             }
   13701                         }
   13702                     }
   13703                 }
   13704             }
   13705             ios.precision(60);
   13706             {
   13707                 nouppercase(ios);
   13708                 {
   13709                     noshowpos(ios);
   13710                     {
   13711                         noshowpoint(ios);
   13712                         {
   13713                             ios.imbue(lc);
   13714                             {
   13715                                 ios.width(0);
   13716                                 {
   13717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13718                                     std::string ex(str, iter.base());
   13719                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13720                                     assert(ios.width() == 0);
   13721                                 }
   13722                                 ios.width(25);
   13723                                 left(ios);
   13724                                 {
   13725                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13726                                     std::string ex(str, iter.base());
   13727                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13728                                     assert(ios.width() == 0);
   13729                                 }
   13730                                 ios.width(25);
   13731                                 right(ios);
   13732                                 {
   13733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13734                                     std::string ex(str, iter.base());
   13735                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13736                                     assert(ios.width() == 0);
   13737                                 }
   13738                                 ios.width(25);
   13739                                 internal(ios);
   13740                                 {
   13741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13742                                     std::string ex(str, iter.base());
   13743                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13744                                     assert(ios.width() == 0);
   13745                                 }
   13746                             }
   13747                             ios.imbue(lg);
   13748                             {
   13749                                 ios.width(0);
   13750                                 {
   13751                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13752                                     std::string ex(str, iter.base());
   13753                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13754                                     assert(ios.width() == 0);
   13755                                 }
   13756                                 ios.width(25);
   13757                                 left(ios);
   13758                                 {
   13759                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13760                                     std::string ex(str, iter.base());
   13761                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13762                                     assert(ios.width() == 0);
   13763                                 }
   13764                                 ios.width(25);
   13765                                 right(ios);
   13766                                 {
   13767                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13768                                     std::string ex(str, iter.base());
   13769                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13770                                     assert(ios.width() == 0);
   13771                                 }
   13772                                 ios.width(25);
   13773                                 internal(ios);
   13774                                 {
   13775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13776                                     std::string ex(str, iter.base());
   13777                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13778                                     assert(ios.width() == 0);
   13779                                 }
   13780                             }
   13781                         }
   13782                         showpoint(ios);
   13783                         {
   13784                             ios.imbue(lc);
   13785                             {
   13786                                 ios.width(0);
   13787                                 {
   13788                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13789                                     std::string ex(str, iter.base());
   13790                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13791                                     assert(ios.width() == 0);
   13792                                 }
   13793                                 ios.width(25);
   13794                                 left(ios);
   13795                                 {
   13796                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13797                                     std::string ex(str, iter.base());
   13798                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13799                                     assert(ios.width() == 0);
   13800                                 }
   13801                                 ios.width(25);
   13802                                 right(ios);
   13803                                 {
   13804                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13805                                     std::string ex(str, iter.base());
   13806                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13807                                     assert(ios.width() == 0);
   13808                                 }
   13809                                 ios.width(25);
   13810                                 internal(ios);
   13811                                 {
   13812                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13813                                     std::string ex(str, iter.base());
   13814                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   13815                                     assert(ios.width() == 0);
   13816                                 }
   13817                             }
   13818                             ios.imbue(lg);
   13819                             {
   13820                                 ios.width(0);
   13821                                 {
   13822                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13823                                     std::string ex(str, iter.base());
   13824                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13825                                     assert(ios.width() == 0);
   13826                                 }
   13827                                 ios.width(25);
   13828                                 left(ios);
   13829                                 {
   13830                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13831                                     std::string ex(str, iter.base());
   13832                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13833                                     assert(ios.width() == 0);
   13834                                 }
   13835                                 ios.width(25);
   13836                                 right(ios);
   13837                                 {
   13838                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13839                                     std::string ex(str, iter.base());
   13840                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13841                                     assert(ios.width() == 0);
   13842                                 }
   13843                                 ios.width(25);
   13844                                 internal(ios);
   13845                                 {
   13846                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13847                                     std::string ex(str, iter.base());
   13848                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   13849                                     assert(ios.width() == 0);
   13850                                 }
   13851                             }
   13852                         }
   13853                     }
   13854                     showpos(ios);
   13855                     {
   13856                         noshowpoint(ios);
   13857                         {
   13858                             ios.imbue(lc);
   13859                             {
   13860                                 ios.width(0);
   13861                                 {
   13862                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13863                                     std::string ex(str, iter.base());
   13864                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13865                                     assert(ios.width() == 0);
   13866                                 }
   13867                                 ios.width(25);
   13868                                 left(ios);
   13869                                 {
   13870                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13871                                     std::string ex(str, iter.base());
   13872                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13873                                     assert(ios.width() == 0);
   13874                                 }
   13875                                 ios.width(25);
   13876                                 right(ios);
   13877                                 {
   13878                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13879                                     std::string ex(str, iter.base());
   13880                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13881                                     assert(ios.width() == 0);
   13882                                 }
   13883                                 ios.width(25);
   13884                                 internal(ios);
   13885                                 {
   13886                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13887                                     std::string ex(str, iter.base());
   13888                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13889                                     assert(ios.width() == 0);
   13890                                 }
   13891                             }
   13892                             ios.imbue(lg);
   13893                             {
   13894                                 ios.width(0);
   13895                                 {
   13896                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13897                                     std::string ex(str, iter.base());
   13898                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13899                                     assert(ios.width() == 0);
   13900                                 }
   13901                                 ios.width(25);
   13902                                 left(ios);
   13903                                 {
   13904                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13905                                     std::string ex(str, iter.base());
   13906                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13907                                     assert(ios.width() == 0);
   13908                                 }
   13909                                 ios.width(25);
   13910                                 right(ios);
   13911                                 {
   13912                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13913                                     std::string ex(str, iter.base());
   13914                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13915                                     assert(ios.width() == 0);
   13916                                 }
   13917                                 ios.width(25);
   13918                                 internal(ios);
   13919                                 {
   13920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13921                                     std::string ex(str, iter.base());
   13922                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13923                                     assert(ios.width() == 0);
   13924                                 }
   13925                             }
   13926                         }
   13927                         showpoint(ios);
   13928                         {
   13929                             ios.imbue(lc);
   13930                             {
   13931                                 ios.width(0);
   13932                                 {
   13933                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13934                                     std::string ex(str, iter.base());
   13935                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13936                                     assert(ios.width() == 0);
   13937                                 }
   13938                                 ios.width(25);
   13939                                 left(ios);
   13940                                 {
   13941                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13942                                     std::string ex(str, iter.base());
   13943                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13944                                     assert(ios.width() == 0);
   13945                                 }
   13946                                 ios.width(25);
   13947                                 right(ios);
   13948                                 {
   13949                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13950                                     std::string ex(str, iter.base());
   13951                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13952                                     assert(ios.width() == 0);
   13953                                 }
   13954                                 ios.width(25);
   13955                                 internal(ios);
   13956                                 {
   13957                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13958                                     std::string ex(str, iter.base());
   13959                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   13960                                     assert(ios.width() == 0);
   13961                                 }
   13962                             }
   13963                             ios.imbue(lg);
   13964                             {
   13965                                 ios.width(0);
   13966                                 {
   13967                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13968                                     std::string ex(str, iter.base());
   13969                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13970                                     assert(ios.width() == 0);
   13971                                 }
   13972                                 ios.width(25);
   13973                                 left(ios);
   13974                                 {
   13975                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13976                                     std::string ex(str, iter.base());
   13977                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13978                                     assert(ios.width() == 0);
   13979                                 }
   13980                                 ios.width(25);
   13981                                 right(ios);
   13982                                 {
   13983                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13984                                     std::string ex(str, iter.base());
   13985                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13986                                     assert(ios.width() == 0);
   13987                                 }
   13988                                 ios.width(25);
   13989                                 internal(ios);
   13990                                 {
   13991                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   13992                                     std::string ex(str, iter.base());
   13993                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   13994                                     assert(ios.width() == 0);
   13995                                 }
   13996                             }
   13997                         }
   13998                     }
   13999                 }
   14000                 uppercase(ios);
   14001                 {
   14002                     noshowpos(ios);
   14003                     {
   14004                         noshowpoint(ios);
   14005                         {
   14006                             ios.imbue(lc);
   14007                             {
   14008                                 ios.width(0);
   14009                                 {
   14010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14011                                     std::string ex(str, iter.base());
   14012                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14013                                     assert(ios.width() == 0);
   14014                                 }
   14015                                 ios.width(25);
   14016                                 left(ios);
   14017                                 {
   14018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14019                                     std::string ex(str, iter.base());
   14020                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14021                                     assert(ios.width() == 0);
   14022                                 }
   14023                                 ios.width(25);
   14024                                 right(ios);
   14025                                 {
   14026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14027                                     std::string ex(str, iter.base());
   14028                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14029                                     assert(ios.width() == 0);
   14030                                 }
   14031                                 ios.width(25);
   14032                                 internal(ios);
   14033                                 {
   14034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14035                                     std::string ex(str, iter.base());
   14036                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14037                                     assert(ios.width() == 0);
   14038                                 }
   14039                             }
   14040                             ios.imbue(lg);
   14041                             {
   14042                                 ios.width(0);
   14043                                 {
   14044                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14045                                     std::string ex(str, iter.base());
   14046                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14047                                     assert(ios.width() == 0);
   14048                                 }
   14049                                 ios.width(25);
   14050                                 left(ios);
   14051                                 {
   14052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14053                                     std::string ex(str, iter.base());
   14054                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14055                                     assert(ios.width() == 0);
   14056                                 }
   14057                                 ios.width(25);
   14058                                 right(ios);
   14059                                 {
   14060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14061                                     std::string ex(str, iter.base());
   14062                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14063                                     assert(ios.width() == 0);
   14064                                 }
   14065                                 ios.width(25);
   14066                                 internal(ios);
   14067                                 {
   14068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14069                                     std::string ex(str, iter.base());
   14070                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14071                                     assert(ios.width() == 0);
   14072                                 }
   14073                             }
   14074                         }
   14075                         showpoint(ios);
   14076                         {
   14077                             ios.imbue(lc);
   14078                             {
   14079                                 ios.width(0);
   14080                                 {
   14081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14082                                     std::string ex(str, iter.base());
   14083                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14084                                     assert(ios.width() == 0);
   14085                                 }
   14086                                 ios.width(25);
   14087                                 left(ios);
   14088                                 {
   14089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14090                                     std::string ex(str, iter.base());
   14091                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14092                                     assert(ios.width() == 0);
   14093                                 }
   14094                                 ios.width(25);
   14095                                 right(ios);
   14096                                 {
   14097                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14098                                     std::string ex(str, iter.base());
   14099                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14100                                     assert(ios.width() == 0);
   14101                                 }
   14102                                 ios.width(25);
   14103                                 internal(ios);
   14104                                 {
   14105                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14106                                     std::string ex(str, iter.base());
   14107                                     assert(ex == "0.000000000000000000000000000000000000000000000000000000000000");
   14108                                     assert(ios.width() == 0);
   14109                                 }
   14110                             }
   14111                             ios.imbue(lg);
   14112                             {
   14113                                 ios.width(0);
   14114                                 {
   14115                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14116                                     std::string ex(str, iter.base());
   14117                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14118                                     assert(ios.width() == 0);
   14119                                 }
   14120                                 ios.width(25);
   14121                                 left(ios);
   14122                                 {
   14123                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14124                                     std::string ex(str, iter.base());
   14125                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14126                                     assert(ios.width() == 0);
   14127                                 }
   14128                                 ios.width(25);
   14129                                 right(ios);
   14130                                 {
   14131                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14132                                     std::string ex(str, iter.base());
   14133                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14134                                     assert(ios.width() == 0);
   14135                                 }
   14136                                 ios.width(25);
   14137                                 internal(ios);
   14138                                 {
   14139                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14140                                     std::string ex(str, iter.base());
   14141                                     assert(ex == "0;000000000000000000000000000000000000000000000000000000000000");
   14142                                     assert(ios.width() == 0);
   14143                                 }
   14144                             }
   14145                         }
   14146                     }
   14147                     showpos(ios);
   14148                     {
   14149                         noshowpoint(ios);
   14150                         {
   14151                             ios.imbue(lc);
   14152                             {
   14153                                 ios.width(0);
   14154                                 {
   14155                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14156                                     std::string ex(str, iter.base());
   14157                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14158                                     assert(ios.width() == 0);
   14159                                 }
   14160                                 ios.width(25);
   14161                                 left(ios);
   14162                                 {
   14163                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14164                                     std::string ex(str, iter.base());
   14165                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14166                                     assert(ios.width() == 0);
   14167                                 }
   14168                                 ios.width(25);
   14169                                 right(ios);
   14170                                 {
   14171                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14172                                     std::string ex(str, iter.base());
   14173                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14174                                     assert(ios.width() == 0);
   14175                                 }
   14176                                 ios.width(25);
   14177                                 internal(ios);
   14178                                 {
   14179                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14180                                     std::string ex(str, iter.base());
   14181                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14182                                     assert(ios.width() == 0);
   14183                                 }
   14184                             }
   14185                             ios.imbue(lg);
   14186                             {
   14187                                 ios.width(0);
   14188                                 {
   14189                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14190                                     std::string ex(str, iter.base());
   14191                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14192                                     assert(ios.width() == 0);
   14193                                 }
   14194                                 ios.width(25);
   14195                                 left(ios);
   14196                                 {
   14197                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14198                                     std::string ex(str, iter.base());
   14199                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14200                                     assert(ios.width() == 0);
   14201                                 }
   14202                                 ios.width(25);
   14203                                 right(ios);
   14204                                 {
   14205                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14206                                     std::string ex(str, iter.base());
   14207                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14208                                     assert(ios.width() == 0);
   14209                                 }
   14210                                 ios.width(25);
   14211                                 internal(ios);
   14212                                 {
   14213                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14214                                     std::string ex(str, iter.base());
   14215                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14216                                     assert(ios.width() == 0);
   14217                                 }
   14218                             }
   14219                         }
   14220                         showpoint(ios);
   14221                         {
   14222                             ios.imbue(lc);
   14223                             {
   14224                                 ios.width(0);
   14225                                 {
   14226                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14227                                     std::string ex(str, iter.base());
   14228                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14229                                     assert(ios.width() == 0);
   14230                                 }
   14231                                 ios.width(25);
   14232                                 left(ios);
   14233                                 {
   14234                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14235                                     std::string ex(str, iter.base());
   14236                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14237                                     assert(ios.width() == 0);
   14238                                 }
   14239                                 ios.width(25);
   14240                                 right(ios);
   14241                                 {
   14242                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14243                                     std::string ex(str, iter.base());
   14244                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14245                                     assert(ios.width() == 0);
   14246                                 }
   14247                                 ios.width(25);
   14248                                 internal(ios);
   14249                                 {
   14250                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14251                                     std::string ex(str, iter.base());
   14252                                     assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000");
   14253                                     assert(ios.width() == 0);
   14254                                 }
   14255                             }
   14256                             ios.imbue(lg);
   14257                             {
   14258                                 ios.width(0);
   14259                                 {
   14260                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14261                                     std::string ex(str, iter.base());
   14262                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14263                                     assert(ios.width() == 0);
   14264                                 }
   14265                                 ios.width(25);
   14266                                 left(ios);
   14267                                 {
   14268                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14269                                     std::string ex(str, iter.base());
   14270                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14271                                     assert(ios.width() == 0);
   14272                                 }
   14273                                 ios.width(25);
   14274                                 right(ios);
   14275                                 {
   14276                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14277                                     std::string ex(str, iter.base());
   14278                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14279                                     assert(ios.width() == 0);
   14280                                 }
   14281                                 ios.width(25);
   14282                                 internal(ios);
   14283                                 {
   14284                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14285                                     std::string ex(str, iter.base());
   14286                                     assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000");
   14287                                     assert(ios.width() == 0);
   14288                                 }
   14289                             }
   14290                         }
   14291                     }
   14292                 }
   14293             }
   14294         }
   14295     }
   14296 }
   14297 
   14298 void test7()
   14299 {
   14300     char str[200];
   14301     output_iterator<char*> iter;
   14302     std::locale lc = std::locale::classic();
   14303     std::locale lg(lc, new my_numpunct);
   14304     const my_facet f(1);
   14305     {
   14306         long double v = -0.;
   14307         std::ios ios(0);
   14308         fixed(ios);
   14309         // %f
   14310         {
   14311             ios.precision(0);
   14312             {
   14313                 nouppercase(ios);
   14314                 {
   14315                     noshowpos(ios);
   14316                     {
   14317                         noshowpoint(ios);
   14318                         {
   14319                             ios.imbue(lc);
   14320                             {
   14321                                 ios.width(0);
   14322                                 {
   14323                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14324                                     std::string ex(str, iter.base());
   14325                                     assert(ex == "-0");
   14326                                     assert(ios.width() == 0);
   14327                                 }
   14328                                 ios.width(25);
   14329                                 left(ios);
   14330                                 {
   14331                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14332                                     std::string ex(str, iter.base());
   14333                                     assert(ex == "-0***********************");
   14334                                     assert(ios.width() == 0);
   14335                                 }
   14336                                 ios.width(25);
   14337                                 right(ios);
   14338                                 {
   14339                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14340                                     std::string ex(str, iter.base());
   14341                                     assert(ex == "***********************-0");
   14342                                     assert(ios.width() == 0);
   14343                                 }
   14344                                 ios.width(25);
   14345                                 internal(ios);
   14346                                 {
   14347                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14348                                     std::string ex(str, iter.base());
   14349                                     assert(ex == "-***********************0");
   14350                                     assert(ios.width() == 0);
   14351                                 }
   14352                             }
   14353                             ios.imbue(lg);
   14354                             {
   14355                                 ios.width(0);
   14356                                 {
   14357                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14358                                     std::string ex(str, iter.base());
   14359                                     assert(ex == "-0");
   14360                                     assert(ios.width() == 0);
   14361                                 }
   14362                                 ios.width(25);
   14363                                 left(ios);
   14364                                 {
   14365                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14366                                     std::string ex(str, iter.base());
   14367                                     assert(ex == "-0***********************");
   14368                                     assert(ios.width() == 0);
   14369                                 }
   14370                                 ios.width(25);
   14371                                 right(ios);
   14372                                 {
   14373                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14374                                     std::string ex(str, iter.base());
   14375                                     assert(ex == "***********************-0");
   14376                                     assert(ios.width() == 0);
   14377                                 }
   14378                                 ios.width(25);
   14379                                 internal(ios);
   14380                                 {
   14381                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14382                                     std::string ex(str, iter.base());
   14383                                     assert(ex == "-***********************0");
   14384                                     assert(ios.width() == 0);
   14385                                 }
   14386                             }
   14387                         }
   14388                         showpoint(ios);
   14389                         {
   14390                             ios.imbue(lc);
   14391                             {
   14392                                 ios.width(0);
   14393                                 {
   14394                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14395                                     std::string ex(str, iter.base());
   14396                                     assert(ex == "-0.");
   14397                                     assert(ios.width() == 0);
   14398                                 }
   14399                                 ios.width(25);
   14400                                 left(ios);
   14401                                 {
   14402                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14403                                     std::string ex(str, iter.base());
   14404                                     assert(ex == "-0.**********************");
   14405                                     assert(ios.width() == 0);
   14406                                 }
   14407                                 ios.width(25);
   14408                                 right(ios);
   14409                                 {
   14410                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14411                                     std::string ex(str, iter.base());
   14412                                     assert(ex == "**********************-0.");
   14413                                     assert(ios.width() == 0);
   14414                                 }
   14415                                 ios.width(25);
   14416                                 internal(ios);
   14417                                 {
   14418                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14419                                     std::string ex(str, iter.base());
   14420                                     assert(ex == "-**********************0.");
   14421                                     assert(ios.width() == 0);
   14422                                 }
   14423                             }
   14424                             ios.imbue(lg);
   14425                             {
   14426                                 ios.width(0);
   14427                                 {
   14428                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14429                                     std::string ex(str, iter.base());
   14430                                     assert(ex == "-0;");
   14431                                     assert(ios.width() == 0);
   14432                                 }
   14433                                 ios.width(25);
   14434                                 left(ios);
   14435                                 {
   14436                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14437                                     std::string ex(str, iter.base());
   14438                                     assert(ex == "-0;**********************");
   14439                                     assert(ios.width() == 0);
   14440                                 }
   14441                                 ios.width(25);
   14442                                 right(ios);
   14443                                 {
   14444                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14445                                     std::string ex(str, iter.base());
   14446                                     assert(ex == "**********************-0;");
   14447                                     assert(ios.width() == 0);
   14448                                 }
   14449                                 ios.width(25);
   14450                                 internal(ios);
   14451                                 {
   14452                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14453                                     std::string ex(str, iter.base());
   14454                                     assert(ex == "-**********************0;");
   14455                                     assert(ios.width() == 0);
   14456                                 }
   14457                             }
   14458                         }
   14459                     }
   14460                     showpos(ios);
   14461                     {
   14462                         noshowpoint(ios);
   14463                         {
   14464                             ios.imbue(lc);
   14465                             {
   14466                                 ios.width(0);
   14467                                 {
   14468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14469                                     std::string ex(str, iter.base());
   14470                                     assert(ex == "-0");
   14471                                     assert(ios.width() == 0);
   14472                                 }
   14473                                 ios.width(25);
   14474                                 left(ios);
   14475                                 {
   14476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14477                                     std::string ex(str, iter.base());
   14478                                     assert(ex == "-0***********************");
   14479                                     assert(ios.width() == 0);
   14480                                 }
   14481                                 ios.width(25);
   14482                                 right(ios);
   14483                                 {
   14484                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14485                                     std::string ex(str, iter.base());
   14486                                     assert(ex == "***********************-0");
   14487                                     assert(ios.width() == 0);
   14488                                 }
   14489                                 ios.width(25);
   14490                                 internal(ios);
   14491                                 {
   14492                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14493                                     std::string ex(str, iter.base());
   14494                                     assert(ex == "-***********************0");
   14495                                     assert(ios.width() == 0);
   14496                                 }
   14497                             }
   14498                             ios.imbue(lg);
   14499                             {
   14500                                 ios.width(0);
   14501                                 {
   14502                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14503                                     std::string ex(str, iter.base());
   14504                                     assert(ex == "-0");
   14505                                     assert(ios.width() == 0);
   14506                                 }
   14507                                 ios.width(25);
   14508                                 left(ios);
   14509                                 {
   14510                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14511                                     std::string ex(str, iter.base());
   14512                                     assert(ex == "-0***********************");
   14513                                     assert(ios.width() == 0);
   14514                                 }
   14515                                 ios.width(25);
   14516                                 right(ios);
   14517                                 {
   14518                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14519                                     std::string ex(str, iter.base());
   14520                                     assert(ex == "***********************-0");
   14521                                     assert(ios.width() == 0);
   14522                                 }
   14523                                 ios.width(25);
   14524                                 internal(ios);
   14525                                 {
   14526                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14527                                     std::string ex(str, iter.base());
   14528                                     assert(ex == "-***********************0");
   14529                                     assert(ios.width() == 0);
   14530                                 }
   14531                             }
   14532                         }
   14533                         showpoint(ios);
   14534                         {
   14535                             ios.imbue(lc);
   14536                             {
   14537                                 ios.width(0);
   14538                                 {
   14539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14540                                     std::string ex(str, iter.base());
   14541                                     assert(ex == "-0.");
   14542                                     assert(ios.width() == 0);
   14543                                 }
   14544                                 ios.width(25);
   14545                                 left(ios);
   14546                                 {
   14547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14548                                     std::string ex(str, iter.base());
   14549                                     assert(ex == "-0.**********************");
   14550                                     assert(ios.width() == 0);
   14551                                 }
   14552                                 ios.width(25);
   14553                                 right(ios);
   14554                                 {
   14555                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14556                                     std::string ex(str, iter.base());
   14557                                     assert(ex == "**********************-0.");
   14558                                     assert(ios.width() == 0);
   14559                                 }
   14560                                 ios.width(25);
   14561                                 internal(ios);
   14562                                 {
   14563                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14564                                     std::string ex(str, iter.base());
   14565                                     assert(ex == "-**********************0.");
   14566                                     assert(ios.width() == 0);
   14567                                 }
   14568                             }
   14569                             ios.imbue(lg);
   14570                             {
   14571                                 ios.width(0);
   14572                                 {
   14573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14574                                     std::string ex(str, iter.base());
   14575                                     assert(ex == "-0;");
   14576                                     assert(ios.width() == 0);
   14577                                 }
   14578                                 ios.width(25);
   14579                                 left(ios);
   14580                                 {
   14581                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14582                                     std::string ex(str, iter.base());
   14583                                     assert(ex == "-0;**********************");
   14584                                     assert(ios.width() == 0);
   14585                                 }
   14586                                 ios.width(25);
   14587                                 right(ios);
   14588                                 {
   14589                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14590                                     std::string ex(str, iter.base());
   14591                                     assert(ex == "**********************-0;");
   14592                                     assert(ios.width() == 0);
   14593                                 }
   14594                                 ios.width(25);
   14595                                 internal(ios);
   14596                                 {
   14597                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14598                                     std::string ex(str, iter.base());
   14599                                     assert(ex == "-**********************0;");
   14600                                     assert(ios.width() == 0);
   14601                                 }
   14602                             }
   14603                         }
   14604                     }
   14605                 }
   14606                 uppercase(ios);
   14607                 {
   14608                     noshowpos(ios);
   14609                     {
   14610                         noshowpoint(ios);
   14611                         {
   14612                             ios.imbue(lc);
   14613                             {
   14614                                 ios.width(0);
   14615                                 {
   14616                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14617                                     std::string ex(str, iter.base());
   14618                                     assert(ex == "-0");
   14619                                     assert(ios.width() == 0);
   14620                                 }
   14621                                 ios.width(25);
   14622                                 left(ios);
   14623                                 {
   14624                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14625                                     std::string ex(str, iter.base());
   14626                                     assert(ex == "-0***********************");
   14627                                     assert(ios.width() == 0);
   14628                                 }
   14629                                 ios.width(25);
   14630                                 right(ios);
   14631                                 {
   14632                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14633                                     std::string ex(str, iter.base());
   14634                                     assert(ex == "***********************-0");
   14635                                     assert(ios.width() == 0);
   14636                                 }
   14637                                 ios.width(25);
   14638                                 internal(ios);
   14639                                 {
   14640                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14641                                     std::string ex(str, iter.base());
   14642                                     assert(ex == "-***********************0");
   14643                                     assert(ios.width() == 0);
   14644                                 }
   14645                             }
   14646                             ios.imbue(lg);
   14647                             {
   14648                                 ios.width(0);
   14649                                 {
   14650                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14651                                     std::string ex(str, iter.base());
   14652                                     assert(ex == "-0");
   14653                                     assert(ios.width() == 0);
   14654                                 }
   14655                                 ios.width(25);
   14656                                 left(ios);
   14657                                 {
   14658                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14659                                     std::string ex(str, iter.base());
   14660                                     assert(ex == "-0***********************");
   14661                                     assert(ios.width() == 0);
   14662                                 }
   14663                                 ios.width(25);
   14664                                 right(ios);
   14665                                 {
   14666                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14667                                     std::string ex(str, iter.base());
   14668                                     assert(ex == "***********************-0");
   14669                                     assert(ios.width() == 0);
   14670                                 }
   14671                                 ios.width(25);
   14672                                 internal(ios);
   14673                                 {
   14674                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14675                                     std::string ex(str, iter.base());
   14676                                     assert(ex == "-***********************0");
   14677                                     assert(ios.width() == 0);
   14678                                 }
   14679                             }
   14680                         }
   14681                         showpoint(ios);
   14682                         {
   14683                             ios.imbue(lc);
   14684                             {
   14685                                 ios.width(0);
   14686                                 {
   14687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14688                                     std::string ex(str, iter.base());
   14689                                     assert(ex == "-0.");
   14690                                     assert(ios.width() == 0);
   14691                                 }
   14692                                 ios.width(25);
   14693                                 left(ios);
   14694                                 {
   14695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14696                                     std::string ex(str, iter.base());
   14697                                     assert(ex == "-0.**********************");
   14698                                     assert(ios.width() == 0);
   14699                                 }
   14700                                 ios.width(25);
   14701                                 right(ios);
   14702                                 {
   14703                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14704                                     std::string ex(str, iter.base());
   14705                                     assert(ex == "**********************-0.");
   14706                                     assert(ios.width() == 0);
   14707                                 }
   14708                                 ios.width(25);
   14709                                 internal(ios);
   14710                                 {
   14711                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14712                                     std::string ex(str, iter.base());
   14713                                     assert(ex == "-**********************0.");
   14714                                     assert(ios.width() == 0);
   14715                                 }
   14716                             }
   14717                             ios.imbue(lg);
   14718                             {
   14719                                 ios.width(0);
   14720                                 {
   14721                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14722                                     std::string ex(str, iter.base());
   14723                                     assert(ex == "-0;");
   14724                                     assert(ios.width() == 0);
   14725                                 }
   14726                                 ios.width(25);
   14727                                 left(ios);
   14728                                 {
   14729                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14730                                     std::string ex(str, iter.base());
   14731                                     assert(ex == "-0;**********************");
   14732                                     assert(ios.width() == 0);
   14733                                 }
   14734                                 ios.width(25);
   14735                                 right(ios);
   14736                                 {
   14737                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14738                                     std::string ex(str, iter.base());
   14739                                     assert(ex == "**********************-0;");
   14740                                     assert(ios.width() == 0);
   14741                                 }
   14742                                 ios.width(25);
   14743                                 internal(ios);
   14744                                 {
   14745                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14746                                     std::string ex(str, iter.base());
   14747                                     assert(ex == "-**********************0;");
   14748                                     assert(ios.width() == 0);
   14749                                 }
   14750                             }
   14751                         }
   14752                     }
   14753                     showpos(ios);
   14754                     {
   14755                         noshowpoint(ios);
   14756                         {
   14757                             ios.imbue(lc);
   14758                             {
   14759                                 ios.width(0);
   14760                                 {
   14761                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14762                                     std::string ex(str, iter.base());
   14763                                     assert(ex == "-0");
   14764                                     assert(ios.width() == 0);
   14765                                 }
   14766                                 ios.width(25);
   14767                                 left(ios);
   14768                                 {
   14769                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14770                                     std::string ex(str, iter.base());
   14771                                     assert(ex == "-0***********************");
   14772                                     assert(ios.width() == 0);
   14773                                 }
   14774                                 ios.width(25);
   14775                                 right(ios);
   14776                                 {
   14777                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14778                                     std::string ex(str, iter.base());
   14779                                     assert(ex == "***********************-0");
   14780                                     assert(ios.width() == 0);
   14781                                 }
   14782                                 ios.width(25);
   14783                                 internal(ios);
   14784                                 {
   14785                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14786                                     std::string ex(str, iter.base());
   14787                                     assert(ex == "-***********************0");
   14788                                     assert(ios.width() == 0);
   14789                                 }
   14790                             }
   14791                             ios.imbue(lg);
   14792                             {
   14793                                 ios.width(0);
   14794                                 {
   14795                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14796                                     std::string ex(str, iter.base());
   14797                                     assert(ex == "-0");
   14798                                     assert(ios.width() == 0);
   14799                                 }
   14800                                 ios.width(25);
   14801                                 left(ios);
   14802                                 {
   14803                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14804                                     std::string ex(str, iter.base());
   14805                                     assert(ex == "-0***********************");
   14806                                     assert(ios.width() == 0);
   14807                                 }
   14808                                 ios.width(25);
   14809                                 right(ios);
   14810                                 {
   14811                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14812                                     std::string ex(str, iter.base());
   14813                                     assert(ex == "***********************-0");
   14814                                     assert(ios.width() == 0);
   14815                                 }
   14816                                 ios.width(25);
   14817                                 internal(ios);
   14818                                 {
   14819                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14820                                     std::string ex(str, iter.base());
   14821                                     assert(ex == "-***********************0");
   14822                                     assert(ios.width() == 0);
   14823                                 }
   14824                             }
   14825                         }
   14826                         showpoint(ios);
   14827                         {
   14828                             ios.imbue(lc);
   14829                             {
   14830                                 ios.width(0);
   14831                                 {
   14832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14833                                     std::string ex(str, iter.base());
   14834                                     assert(ex == "-0.");
   14835                                     assert(ios.width() == 0);
   14836                                 }
   14837                                 ios.width(25);
   14838                                 left(ios);
   14839                                 {
   14840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14841                                     std::string ex(str, iter.base());
   14842                                     assert(ex == "-0.**********************");
   14843                                     assert(ios.width() == 0);
   14844                                 }
   14845                                 ios.width(25);
   14846                                 right(ios);
   14847                                 {
   14848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14849                                     std::string ex(str, iter.base());
   14850                                     assert(ex == "**********************-0.");
   14851                                     assert(ios.width() == 0);
   14852                                 }
   14853                                 ios.width(25);
   14854                                 internal(ios);
   14855                                 {
   14856                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14857                                     std::string ex(str, iter.base());
   14858                                     assert(ex == "-**********************0.");
   14859                                     assert(ios.width() == 0);
   14860                                 }
   14861                             }
   14862                             ios.imbue(lg);
   14863                             {
   14864                                 ios.width(0);
   14865                                 {
   14866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14867                                     std::string ex(str, iter.base());
   14868                                     assert(ex == "-0;");
   14869                                     assert(ios.width() == 0);
   14870                                 }
   14871                                 ios.width(25);
   14872                                 left(ios);
   14873                                 {
   14874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14875                                     std::string ex(str, iter.base());
   14876                                     assert(ex == "-0;**********************");
   14877                                     assert(ios.width() == 0);
   14878                                 }
   14879                                 ios.width(25);
   14880                                 right(ios);
   14881                                 {
   14882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14883                                     std::string ex(str, iter.base());
   14884                                     assert(ex == "**********************-0;");
   14885                                     assert(ios.width() == 0);
   14886                                 }
   14887                                 ios.width(25);
   14888                                 internal(ios);
   14889                                 {
   14890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14891                                     std::string ex(str, iter.base());
   14892                                     assert(ex == "-**********************0;");
   14893                                     assert(ios.width() == 0);
   14894                                 }
   14895                             }
   14896                         }
   14897                     }
   14898                 }
   14899             }
   14900             ios.precision(1);
   14901             {
   14902                 nouppercase(ios);
   14903                 {
   14904                     noshowpos(ios);
   14905                     {
   14906                         noshowpoint(ios);
   14907                         {
   14908                             ios.imbue(lc);
   14909                             {
   14910                                 ios.width(0);
   14911                                 {
   14912                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14913                                     std::string ex(str, iter.base());
   14914                                     assert(ex == "-0.0");
   14915                                     assert(ios.width() == 0);
   14916                                 }
   14917                                 ios.width(25);
   14918                                 left(ios);
   14919                                 {
   14920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14921                                     std::string ex(str, iter.base());
   14922                                     assert(ex == "-0.0*********************");
   14923                                     assert(ios.width() == 0);
   14924                                 }
   14925                                 ios.width(25);
   14926                                 right(ios);
   14927                                 {
   14928                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14929                                     std::string ex(str, iter.base());
   14930                                     assert(ex == "*********************-0.0");
   14931                                     assert(ios.width() == 0);
   14932                                 }
   14933                                 ios.width(25);
   14934                                 internal(ios);
   14935                                 {
   14936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14937                                     std::string ex(str, iter.base());
   14938                                     assert(ex == "-*********************0.0");
   14939                                     assert(ios.width() == 0);
   14940                                 }
   14941                             }
   14942                             ios.imbue(lg);
   14943                             {
   14944                                 ios.width(0);
   14945                                 {
   14946                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14947                                     std::string ex(str, iter.base());
   14948                                     assert(ex == "-0;0");
   14949                                     assert(ios.width() == 0);
   14950                                 }
   14951                                 ios.width(25);
   14952                                 left(ios);
   14953                                 {
   14954                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14955                                     std::string ex(str, iter.base());
   14956                                     assert(ex == "-0;0*********************");
   14957                                     assert(ios.width() == 0);
   14958                                 }
   14959                                 ios.width(25);
   14960                                 right(ios);
   14961                                 {
   14962                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14963                                     std::string ex(str, iter.base());
   14964                                     assert(ex == "*********************-0;0");
   14965                                     assert(ios.width() == 0);
   14966                                 }
   14967                                 ios.width(25);
   14968                                 internal(ios);
   14969                                 {
   14970                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14971                                     std::string ex(str, iter.base());
   14972                                     assert(ex == "-*********************0;0");
   14973                                     assert(ios.width() == 0);
   14974                                 }
   14975                             }
   14976                         }
   14977                         showpoint(ios);
   14978                         {
   14979                             ios.imbue(lc);
   14980                             {
   14981                                 ios.width(0);
   14982                                 {
   14983                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14984                                     std::string ex(str, iter.base());
   14985                                     assert(ex == "-0.0");
   14986                                     assert(ios.width() == 0);
   14987                                 }
   14988                                 ios.width(25);
   14989                                 left(ios);
   14990                                 {
   14991                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   14992                                     std::string ex(str, iter.base());
   14993                                     assert(ex == "-0.0*********************");
   14994                                     assert(ios.width() == 0);
   14995                                 }
   14996                                 ios.width(25);
   14997                                 right(ios);
   14998                                 {
   14999                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15000                                     std::string ex(str, iter.base());
   15001                                     assert(ex == "*********************-0.0");
   15002                                     assert(ios.width() == 0);
   15003                                 }
   15004                                 ios.width(25);
   15005                                 internal(ios);
   15006                                 {
   15007                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15008                                     std::string ex(str, iter.base());
   15009                                     assert(ex == "-*********************0.0");
   15010                                     assert(ios.width() == 0);
   15011                                 }
   15012                             }
   15013                             ios.imbue(lg);
   15014                             {
   15015                                 ios.width(0);
   15016                                 {
   15017                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15018                                     std::string ex(str, iter.base());
   15019                                     assert(ex == "-0;0");
   15020                                     assert(ios.width() == 0);
   15021                                 }
   15022                                 ios.width(25);
   15023                                 left(ios);
   15024                                 {
   15025                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15026                                     std::string ex(str, iter.base());
   15027                                     assert(ex == "-0;0*********************");
   15028                                     assert(ios.width() == 0);
   15029                                 }
   15030                                 ios.width(25);
   15031                                 right(ios);
   15032                                 {
   15033                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15034                                     std::string ex(str, iter.base());
   15035                                     assert(ex == "*********************-0;0");
   15036                                     assert(ios.width() == 0);
   15037                                 }
   15038                                 ios.width(25);
   15039                                 internal(ios);
   15040                                 {
   15041                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15042                                     std::string ex(str, iter.base());
   15043                                     assert(ex == "-*********************0;0");
   15044                                     assert(ios.width() == 0);
   15045                                 }
   15046                             }
   15047                         }
   15048                     }
   15049                     showpos(ios);
   15050                     {
   15051                         noshowpoint(ios);
   15052                         {
   15053                             ios.imbue(lc);
   15054                             {
   15055                                 ios.width(0);
   15056                                 {
   15057                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15058                                     std::string ex(str, iter.base());
   15059                                     assert(ex == "-0.0");
   15060                                     assert(ios.width() == 0);
   15061                                 }
   15062                                 ios.width(25);
   15063                                 left(ios);
   15064                                 {
   15065                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15066                                     std::string ex(str, iter.base());
   15067                                     assert(ex == "-0.0*********************");
   15068                                     assert(ios.width() == 0);
   15069                                 }
   15070                                 ios.width(25);
   15071                                 right(ios);
   15072                                 {
   15073                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15074                                     std::string ex(str, iter.base());
   15075                                     assert(ex == "*********************-0.0");
   15076                                     assert(ios.width() == 0);
   15077                                 }
   15078                                 ios.width(25);
   15079                                 internal(ios);
   15080                                 {
   15081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15082                                     std::string ex(str, iter.base());
   15083                                     assert(ex == "-*********************0.0");
   15084                                     assert(ios.width() == 0);
   15085                                 }
   15086                             }
   15087                             ios.imbue(lg);
   15088                             {
   15089                                 ios.width(0);
   15090                                 {
   15091                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15092                                     std::string ex(str, iter.base());
   15093                                     assert(ex == "-0;0");
   15094                                     assert(ios.width() == 0);
   15095                                 }
   15096                                 ios.width(25);
   15097                                 left(ios);
   15098                                 {
   15099                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15100                                     std::string ex(str, iter.base());
   15101                                     assert(ex == "-0;0*********************");
   15102                                     assert(ios.width() == 0);
   15103                                 }
   15104                                 ios.width(25);
   15105                                 right(ios);
   15106                                 {
   15107                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15108                                     std::string ex(str, iter.base());
   15109                                     assert(ex == "*********************-0;0");
   15110                                     assert(ios.width() == 0);
   15111                                 }
   15112                                 ios.width(25);
   15113                                 internal(ios);
   15114                                 {
   15115                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15116                                     std::string ex(str, iter.base());
   15117                                     assert(ex == "-*********************0;0");
   15118                                     assert(ios.width() == 0);
   15119                                 }
   15120                             }
   15121                         }
   15122                         showpoint(ios);
   15123                         {
   15124                             ios.imbue(lc);
   15125                             {
   15126                                 ios.width(0);
   15127                                 {
   15128                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15129                                     std::string ex(str, iter.base());
   15130                                     assert(ex == "-0.0");
   15131                                     assert(ios.width() == 0);
   15132                                 }
   15133                                 ios.width(25);
   15134                                 left(ios);
   15135                                 {
   15136                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15137                                     std::string ex(str, iter.base());
   15138                                     assert(ex == "-0.0*********************");
   15139                                     assert(ios.width() == 0);
   15140                                 }
   15141                                 ios.width(25);
   15142                                 right(ios);
   15143                                 {
   15144                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15145                                     std::string ex(str, iter.base());
   15146                                     assert(ex == "*********************-0.0");
   15147                                     assert(ios.width() == 0);
   15148                                 }
   15149                                 ios.width(25);
   15150                                 internal(ios);
   15151                                 {
   15152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15153                                     std::string ex(str, iter.base());
   15154                                     assert(ex == "-*********************0.0");
   15155                                     assert(ios.width() == 0);
   15156                                 }
   15157                             }
   15158                             ios.imbue(lg);
   15159                             {
   15160                                 ios.width(0);
   15161                                 {
   15162                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15163                                     std::string ex(str, iter.base());
   15164                                     assert(ex == "-0;0");
   15165                                     assert(ios.width() == 0);
   15166                                 }
   15167                                 ios.width(25);
   15168                                 left(ios);
   15169                                 {
   15170                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15171                                     std::string ex(str, iter.base());
   15172                                     assert(ex == "-0;0*********************");
   15173                                     assert(ios.width() == 0);
   15174                                 }
   15175                                 ios.width(25);
   15176                                 right(ios);
   15177                                 {
   15178                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15179                                     std::string ex(str, iter.base());
   15180                                     assert(ex == "*********************-0;0");
   15181                                     assert(ios.width() == 0);
   15182                                 }
   15183                                 ios.width(25);
   15184                                 internal(ios);
   15185                                 {
   15186                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15187                                     std::string ex(str, iter.base());
   15188                                     assert(ex == "-*********************0;0");
   15189                                     assert(ios.width() == 0);
   15190                                 }
   15191                             }
   15192                         }
   15193                     }
   15194                 }
   15195                 uppercase(ios);
   15196                 {
   15197                     noshowpos(ios);
   15198                     {
   15199                         noshowpoint(ios);
   15200                         {
   15201                             ios.imbue(lc);
   15202                             {
   15203                                 ios.width(0);
   15204                                 {
   15205                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15206                                     std::string ex(str, iter.base());
   15207                                     assert(ex == "-0.0");
   15208                                     assert(ios.width() == 0);
   15209                                 }
   15210                                 ios.width(25);
   15211                                 left(ios);
   15212                                 {
   15213                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15214                                     std::string ex(str, iter.base());
   15215                                     assert(ex == "-0.0*********************");
   15216                                     assert(ios.width() == 0);
   15217                                 }
   15218                                 ios.width(25);
   15219                                 right(ios);
   15220                                 {
   15221                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15222                                     std::string ex(str, iter.base());
   15223                                     assert(ex == "*********************-0.0");
   15224                                     assert(ios.width() == 0);
   15225                                 }
   15226                                 ios.width(25);
   15227                                 internal(ios);
   15228                                 {
   15229                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15230                                     std::string ex(str, iter.base());
   15231                                     assert(ex == "-*********************0.0");
   15232                                     assert(ios.width() == 0);
   15233                                 }
   15234                             }
   15235                             ios.imbue(lg);
   15236                             {
   15237                                 ios.width(0);
   15238                                 {
   15239                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15240                                     std::string ex(str, iter.base());
   15241                                     assert(ex == "-0;0");
   15242                                     assert(ios.width() == 0);
   15243                                 }
   15244                                 ios.width(25);
   15245                                 left(ios);
   15246                                 {
   15247                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15248                                     std::string ex(str, iter.base());
   15249                                     assert(ex == "-0;0*********************");
   15250                                     assert(ios.width() == 0);
   15251                                 }
   15252                                 ios.width(25);
   15253                                 right(ios);
   15254                                 {
   15255                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15256                                     std::string ex(str, iter.base());
   15257                                     assert(ex == "*********************-0;0");
   15258                                     assert(ios.width() == 0);
   15259                                 }
   15260                                 ios.width(25);
   15261                                 internal(ios);
   15262                                 {
   15263                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15264                                     std::string ex(str, iter.base());
   15265                                     assert(ex == "-*********************0;0");
   15266                                     assert(ios.width() == 0);
   15267                                 }
   15268                             }
   15269                         }
   15270                         showpoint(ios);
   15271                         {
   15272                             ios.imbue(lc);
   15273                             {
   15274                                 ios.width(0);
   15275                                 {
   15276                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15277                                     std::string ex(str, iter.base());
   15278                                     assert(ex == "-0.0");
   15279                                     assert(ios.width() == 0);
   15280                                 }
   15281                                 ios.width(25);
   15282                                 left(ios);
   15283                                 {
   15284                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15285                                     std::string ex(str, iter.base());
   15286                                     assert(ex == "-0.0*********************");
   15287                                     assert(ios.width() == 0);
   15288                                 }
   15289                                 ios.width(25);
   15290                                 right(ios);
   15291                                 {
   15292                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15293                                     std::string ex(str, iter.base());
   15294                                     assert(ex == "*********************-0.0");
   15295                                     assert(ios.width() == 0);
   15296                                 }
   15297                                 ios.width(25);
   15298                                 internal(ios);
   15299                                 {
   15300                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15301                                     std::string ex(str, iter.base());
   15302                                     assert(ex == "-*********************0.0");
   15303                                     assert(ios.width() == 0);
   15304                                 }
   15305                             }
   15306                             ios.imbue(lg);
   15307                             {
   15308                                 ios.width(0);
   15309                                 {
   15310                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15311                                     std::string ex(str, iter.base());
   15312                                     assert(ex == "-0;0");
   15313                                     assert(ios.width() == 0);
   15314                                 }
   15315                                 ios.width(25);
   15316                                 left(ios);
   15317                                 {
   15318                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15319                                     std::string ex(str, iter.base());
   15320                                     assert(ex == "-0;0*********************");
   15321                                     assert(ios.width() == 0);
   15322                                 }
   15323                                 ios.width(25);
   15324                                 right(ios);
   15325                                 {
   15326                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15327                                     std::string ex(str, iter.base());
   15328                                     assert(ex == "*********************-0;0");
   15329                                     assert(ios.width() == 0);
   15330                                 }
   15331                                 ios.width(25);
   15332                                 internal(ios);
   15333                                 {
   15334                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15335                                     std::string ex(str, iter.base());
   15336                                     assert(ex == "-*********************0;0");
   15337                                     assert(ios.width() == 0);
   15338                                 }
   15339                             }
   15340                         }
   15341                     }
   15342                     showpos(ios);
   15343                     {
   15344                         noshowpoint(ios);
   15345                         {
   15346                             ios.imbue(lc);
   15347                             {
   15348                                 ios.width(0);
   15349                                 {
   15350                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15351                                     std::string ex(str, iter.base());
   15352                                     assert(ex == "-0.0");
   15353                                     assert(ios.width() == 0);
   15354                                 }
   15355                                 ios.width(25);
   15356                                 left(ios);
   15357                                 {
   15358                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15359                                     std::string ex(str, iter.base());
   15360                                     assert(ex == "-0.0*********************");
   15361                                     assert(ios.width() == 0);
   15362                                 }
   15363                                 ios.width(25);
   15364                                 right(ios);
   15365                                 {
   15366                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15367                                     std::string ex(str, iter.base());
   15368                                     assert(ex == "*********************-0.0");
   15369                                     assert(ios.width() == 0);
   15370                                 }
   15371                                 ios.width(25);
   15372                                 internal(ios);
   15373                                 {
   15374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15375                                     std::string ex(str, iter.base());
   15376                                     assert(ex == "-*********************0.0");
   15377                                     assert(ios.width() == 0);
   15378                                 }
   15379                             }
   15380                             ios.imbue(lg);
   15381                             {
   15382                                 ios.width(0);
   15383                                 {
   15384                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15385                                     std::string ex(str, iter.base());
   15386                                     assert(ex == "-0;0");
   15387                                     assert(ios.width() == 0);
   15388                                 }
   15389                                 ios.width(25);
   15390                                 left(ios);
   15391                                 {
   15392                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15393                                     std::string ex(str, iter.base());
   15394                                     assert(ex == "-0;0*********************");
   15395                                     assert(ios.width() == 0);
   15396                                 }
   15397                                 ios.width(25);
   15398                                 right(ios);
   15399                                 {
   15400                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15401                                     std::string ex(str, iter.base());
   15402                                     assert(ex == "*********************-0;0");
   15403                                     assert(ios.width() == 0);
   15404                                 }
   15405                                 ios.width(25);
   15406                                 internal(ios);
   15407                                 {
   15408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15409                                     std::string ex(str, iter.base());
   15410                                     assert(ex == "-*********************0;0");
   15411                                     assert(ios.width() == 0);
   15412                                 }
   15413                             }
   15414                         }
   15415                         showpoint(ios);
   15416                         {
   15417                             ios.imbue(lc);
   15418                             {
   15419                                 ios.width(0);
   15420                                 {
   15421                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15422                                     std::string ex(str, iter.base());
   15423                                     assert(ex == "-0.0");
   15424                                     assert(ios.width() == 0);
   15425                                 }
   15426                                 ios.width(25);
   15427                                 left(ios);
   15428                                 {
   15429                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15430                                     std::string ex(str, iter.base());
   15431                                     assert(ex == "-0.0*********************");
   15432                                     assert(ios.width() == 0);
   15433                                 }
   15434                                 ios.width(25);
   15435                                 right(ios);
   15436                                 {
   15437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15438                                     std::string ex(str, iter.base());
   15439                                     assert(ex == "*********************-0.0");
   15440                                     assert(ios.width() == 0);
   15441                                 }
   15442                                 ios.width(25);
   15443                                 internal(ios);
   15444                                 {
   15445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15446                                     std::string ex(str, iter.base());
   15447                                     assert(ex == "-*********************0.0");
   15448                                     assert(ios.width() == 0);
   15449                                 }
   15450                             }
   15451                             ios.imbue(lg);
   15452                             {
   15453                                 ios.width(0);
   15454                                 {
   15455                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15456                                     std::string ex(str, iter.base());
   15457                                     assert(ex == "-0;0");
   15458                                     assert(ios.width() == 0);
   15459                                 }
   15460                                 ios.width(25);
   15461                                 left(ios);
   15462                                 {
   15463                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15464                                     std::string ex(str, iter.base());
   15465                                     assert(ex == "-0;0*********************");
   15466                                     assert(ios.width() == 0);
   15467                                 }
   15468                                 ios.width(25);
   15469                                 right(ios);
   15470                                 {
   15471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15472                                     std::string ex(str, iter.base());
   15473                                     assert(ex == "*********************-0;0");
   15474                                     assert(ios.width() == 0);
   15475                                 }
   15476                                 ios.width(25);
   15477                                 internal(ios);
   15478                                 {
   15479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15480                                     std::string ex(str, iter.base());
   15481                                     assert(ex == "-*********************0;0");
   15482                                     assert(ios.width() == 0);
   15483                                 }
   15484                             }
   15485                         }
   15486                     }
   15487                 }
   15488             }
   15489             ios.precision(6);
   15490             {
   15491                 nouppercase(ios);
   15492                 {
   15493                     noshowpos(ios);
   15494                     {
   15495                         noshowpoint(ios);
   15496                         {
   15497                             ios.imbue(lc);
   15498                             {
   15499                                 ios.width(0);
   15500                                 {
   15501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15502                                     std::string ex(str, iter.base());
   15503                                     assert(ex == "-0.000000");
   15504                                     assert(ios.width() == 0);
   15505                                 }
   15506                                 ios.width(25);
   15507                                 left(ios);
   15508                                 {
   15509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15510                                     std::string ex(str, iter.base());
   15511                                     assert(ex == "-0.000000****************");
   15512                                     assert(ios.width() == 0);
   15513                                 }
   15514                                 ios.width(25);
   15515                                 right(ios);
   15516                                 {
   15517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15518                                     std::string ex(str, iter.base());
   15519                                     assert(ex == "****************-0.000000");
   15520                                     assert(ios.width() == 0);
   15521                                 }
   15522                                 ios.width(25);
   15523                                 internal(ios);
   15524                                 {
   15525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15526                                     std::string ex(str, iter.base());
   15527                                     assert(ex == "-****************0.000000");
   15528                                     assert(ios.width() == 0);
   15529                                 }
   15530                             }
   15531                             ios.imbue(lg);
   15532                             {
   15533                                 ios.width(0);
   15534                                 {
   15535                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15536                                     std::string ex(str, iter.base());
   15537                                     assert(ex == "-0;000000");
   15538                                     assert(ios.width() == 0);
   15539                                 }
   15540                                 ios.width(25);
   15541                                 left(ios);
   15542                                 {
   15543                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15544                                     std::string ex(str, iter.base());
   15545                                     assert(ex == "-0;000000****************");
   15546                                     assert(ios.width() == 0);
   15547                                 }
   15548                                 ios.width(25);
   15549                                 right(ios);
   15550                                 {
   15551                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15552                                     std::string ex(str, iter.base());
   15553                                     assert(ex == "****************-0;000000");
   15554                                     assert(ios.width() == 0);
   15555                                 }
   15556                                 ios.width(25);
   15557                                 internal(ios);
   15558                                 {
   15559                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15560                                     std::string ex(str, iter.base());
   15561                                     assert(ex == "-****************0;000000");
   15562                                     assert(ios.width() == 0);
   15563                                 }
   15564                             }
   15565                         }
   15566                         showpoint(ios);
   15567                         {
   15568                             ios.imbue(lc);
   15569                             {
   15570                                 ios.width(0);
   15571                                 {
   15572                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15573                                     std::string ex(str, iter.base());
   15574                                     assert(ex == "-0.000000");
   15575                                     assert(ios.width() == 0);
   15576                                 }
   15577                                 ios.width(25);
   15578                                 left(ios);
   15579                                 {
   15580                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15581                                     std::string ex(str, iter.base());
   15582                                     assert(ex == "-0.000000****************");
   15583                                     assert(ios.width() == 0);
   15584                                 }
   15585                                 ios.width(25);
   15586                                 right(ios);
   15587                                 {
   15588                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15589                                     std::string ex(str, iter.base());
   15590                                     assert(ex == "****************-0.000000");
   15591                                     assert(ios.width() == 0);
   15592                                 }
   15593                                 ios.width(25);
   15594                                 internal(ios);
   15595                                 {
   15596                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15597                                     std::string ex(str, iter.base());
   15598                                     assert(ex == "-****************0.000000");
   15599                                     assert(ios.width() == 0);
   15600                                 }
   15601                             }
   15602                             ios.imbue(lg);
   15603                             {
   15604                                 ios.width(0);
   15605                                 {
   15606                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15607                                     std::string ex(str, iter.base());
   15608                                     assert(ex == "-0;000000");
   15609                                     assert(ios.width() == 0);
   15610                                 }
   15611                                 ios.width(25);
   15612                                 left(ios);
   15613                                 {
   15614                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15615                                     std::string ex(str, iter.base());
   15616                                     assert(ex == "-0;000000****************");
   15617                                     assert(ios.width() == 0);
   15618                                 }
   15619                                 ios.width(25);
   15620                                 right(ios);
   15621                                 {
   15622                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15623                                     std::string ex(str, iter.base());
   15624                                     assert(ex == "****************-0;000000");
   15625                                     assert(ios.width() == 0);
   15626                                 }
   15627                                 ios.width(25);
   15628                                 internal(ios);
   15629                                 {
   15630                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15631                                     std::string ex(str, iter.base());
   15632                                     assert(ex == "-****************0;000000");
   15633                                     assert(ios.width() == 0);
   15634                                 }
   15635                             }
   15636                         }
   15637                     }
   15638                     showpos(ios);
   15639                     {
   15640                         noshowpoint(ios);
   15641                         {
   15642                             ios.imbue(lc);
   15643                             {
   15644                                 ios.width(0);
   15645                                 {
   15646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15647                                     std::string ex(str, iter.base());
   15648                                     assert(ex == "-0.000000");
   15649                                     assert(ios.width() == 0);
   15650                                 }
   15651                                 ios.width(25);
   15652                                 left(ios);
   15653                                 {
   15654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15655                                     std::string ex(str, iter.base());
   15656                                     assert(ex == "-0.000000****************");
   15657                                     assert(ios.width() == 0);
   15658                                 }
   15659                                 ios.width(25);
   15660                                 right(ios);
   15661                                 {
   15662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15663                                     std::string ex(str, iter.base());
   15664                                     assert(ex == "****************-0.000000");
   15665                                     assert(ios.width() == 0);
   15666                                 }
   15667                                 ios.width(25);
   15668                                 internal(ios);
   15669                                 {
   15670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15671                                     std::string ex(str, iter.base());
   15672                                     assert(ex == "-****************0.000000");
   15673                                     assert(ios.width() == 0);
   15674                                 }
   15675                             }
   15676                             ios.imbue(lg);
   15677                             {
   15678                                 ios.width(0);
   15679                                 {
   15680                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15681                                     std::string ex(str, iter.base());
   15682                                     assert(ex == "-0;000000");
   15683                                     assert(ios.width() == 0);
   15684                                 }
   15685                                 ios.width(25);
   15686                                 left(ios);
   15687                                 {
   15688                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15689                                     std::string ex(str, iter.base());
   15690                                     assert(ex == "-0;000000****************");
   15691                                     assert(ios.width() == 0);
   15692                                 }
   15693                                 ios.width(25);
   15694                                 right(ios);
   15695                                 {
   15696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15697                                     std::string ex(str, iter.base());
   15698                                     assert(ex == "****************-0;000000");
   15699                                     assert(ios.width() == 0);
   15700                                 }
   15701                                 ios.width(25);
   15702                                 internal(ios);
   15703                                 {
   15704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15705                                     std::string ex(str, iter.base());
   15706                                     assert(ex == "-****************0;000000");
   15707                                     assert(ios.width() == 0);
   15708                                 }
   15709                             }
   15710                         }
   15711                         showpoint(ios);
   15712                         {
   15713                             ios.imbue(lc);
   15714                             {
   15715                                 ios.width(0);
   15716                                 {
   15717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15718                                     std::string ex(str, iter.base());
   15719                                     assert(ex == "-0.000000");
   15720                                     assert(ios.width() == 0);
   15721                                 }
   15722                                 ios.width(25);
   15723                                 left(ios);
   15724                                 {
   15725                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15726                                     std::string ex(str, iter.base());
   15727                                     assert(ex == "-0.000000****************");
   15728                                     assert(ios.width() == 0);
   15729                                 }
   15730                                 ios.width(25);
   15731                                 right(ios);
   15732                                 {
   15733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15734                                     std::string ex(str, iter.base());
   15735                                     assert(ex == "****************-0.000000");
   15736                                     assert(ios.width() == 0);
   15737                                 }
   15738                                 ios.width(25);
   15739                                 internal(ios);
   15740                                 {
   15741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15742                                     std::string ex(str, iter.base());
   15743                                     assert(ex == "-****************0.000000");
   15744                                     assert(ios.width() == 0);
   15745                                 }
   15746                             }
   15747                             ios.imbue(lg);
   15748                             {
   15749                                 ios.width(0);
   15750                                 {
   15751                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15752                                     std::string ex(str, iter.base());
   15753                                     assert(ex == "-0;000000");
   15754                                     assert(ios.width() == 0);
   15755                                 }
   15756                                 ios.width(25);
   15757                                 left(ios);
   15758                                 {
   15759                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15760                                     std::string ex(str, iter.base());
   15761                                     assert(ex == "-0;000000****************");
   15762                                     assert(ios.width() == 0);
   15763                                 }
   15764                                 ios.width(25);
   15765                                 right(ios);
   15766                                 {
   15767                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15768                                     std::string ex(str, iter.base());
   15769                                     assert(ex == "****************-0;000000");
   15770                                     assert(ios.width() == 0);
   15771                                 }
   15772                                 ios.width(25);
   15773                                 internal(ios);
   15774                                 {
   15775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15776                                     std::string ex(str, iter.base());
   15777                                     assert(ex == "-****************0;000000");
   15778                                     assert(ios.width() == 0);
   15779                                 }
   15780                             }
   15781                         }
   15782                     }
   15783                 }
   15784                 uppercase(ios);
   15785                 {
   15786                     noshowpos(ios);
   15787                     {
   15788                         noshowpoint(ios);
   15789                         {
   15790                             ios.imbue(lc);
   15791                             {
   15792                                 ios.width(0);
   15793                                 {
   15794                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15795                                     std::string ex(str, iter.base());
   15796                                     assert(ex == "-0.000000");
   15797                                     assert(ios.width() == 0);
   15798                                 }
   15799                                 ios.width(25);
   15800                                 left(ios);
   15801                                 {
   15802                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15803                                     std::string ex(str, iter.base());
   15804                                     assert(ex == "-0.000000****************");
   15805                                     assert(ios.width() == 0);
   15806                                 }
   15807                                 ios.width(25);
   15808                                 right(ios);
   15809                                 {
   15810                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15811                                     std::string ex(str, iter.base());
   15812                                     assert(ex == "****************-0.000000");
   15813                                     assert(ios.width() == 0);
   15814                                 }
   15815                                 ios.width(25);
   15816                                 internal(ios);
   15817                                 {
   15818                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15819                                     std::string ex(str, iter.base());
   15820                                     assert(ex == "-****************0.000000");
   15821                                     assert(ios.width() == 0);
   15822                                 }
   15823                             }
   15824                             ios.imbue(lg);
   15825                             {
   15826                                 ios.width(0);
   15827                                 {
   15828                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15829                                     std::string ex(str, iter.base());
   15830                                     assert(ex == "-0;000000");
   15831                                     assert(ios.width() == 0);
   15832                                 }
   15833                                 ios.width(25);
   15834                                 left(ios);
   15835                                 {
   15836                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15837                                     std::string ex(str, iter.base());
   15838                                     assert(ex == "-0;000000****************");
   15839                                     assert(ios.width() == 0);
   15840                                 }
   15841                                 ios.width(25);
   15842                                 right(ios);
   15843                                 {
   15844                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15845                                     std::string ex(str, iter.base());
   15846                                     assert(ex == "****************-0;000000");
   15847                                     assert(ios.width() == 0);
   15848                                 }
   15849                                 ios.width(25);
   15850                                 internal(ios);
   15851                                 {
   15852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15853                                     std::string ex(str, iter.base());
   15854                                     assert(ex == "-****************0;000000");
   15855                                     assert(ios.width() == 0);
   15856                                 }
   15857                             }
   15858                         }
   15859                         showpoint(ios);
   15860                         {
   15861                             ios.imbue(lc);
   15862                             {
   15863                                 ios.width(0);
   15864                                 {
   15865                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15866                                     std::string ex(str, iter.base());
   15867                                     assert(ex == "-0.000000");
   15868                                     assert(ios.width() == 0);
   15869                                 }
   15870                                 ios.width(25);
   15871                                 left(ios);
   15872                                 {
   15873                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15874                                     std::string ex(str, iter.base());
   15875                                     assert(ex == "-0.000000****************");
   15876                                     assert(ios.width() == 0);
   15877                                 }
   15878                                 ios.width(25);
   15879                                 right(ios);
   15880                                 {
   15881                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15882                                     std::string ex(str, iter.base());
   15883                                     assert(ex == "****************-0.000000");
   15884                                     assert(ios.width() == 0);
   15885                                 }
   15886                                 ios.width(25);
   15887                                 internal(ios);
   15888                                 {
   15889                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15890                                     std::string ex(str, iter.base());
   15891                                     assert(ex == "-****************0.000000");
   15892                                     assert(ios.width() == 0);
   15893                                 }
   15894                             }
   15895                             ios.imbue(lg);
   15896                             {
   15897                                 ios.width(0);
   15898                                 {
   15899                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15900                                     std::string ex(str, iter.base());
   15901                                     assert(ex == "-0;000000");
   15902                                     assert(ios.width() == 0);
   15903                                 }
   15904                                 ios.width(25);
   15905                                 left(ios);
   15906                                 {
   15907                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15908                                     std::string ex(str, iter.base());
   15909                                     assert(ex == "-0;000000****************");
   15910                                     assert(ios.width() == 0);
   15911                                 }
   15912                                 ios.width(25);
   15913                                 right(ios);
   15914                                 {
   15915                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15916                                     std::string ex(str, iter.base());
   15917                                     assert(ex == "****************-0;000000");
   15918                                     assert(ios.width() == 0);
   15919                                 }
   15920                                 ios.width(25);
   15921                                 internal(ios);
   15922                                 {
   15923                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15924                                     std::string ex(str, iter.base());
   15925                                     assert(ex == "-****************0;000000");
   15926                                     assert(ios.width() == 0);
   15927                                 }
   15928                             }
   15929                         }
   15930                     }
   15931                     showpos(ios);
   15932                     {
   15933                         noshowpoint(ios);
   15934                         {
   15935                             ios.imbue(lc);
   15936                             {
   15937                                 ios.width(0);
   15938                                 {
   15939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15940                                     std::string ex(str, iter.base());
   15941                                     assert(ex == "-0.000000");
   15942                                     assert(ios.width() == 0);
   15943                                 }
   15944                                 ios.width(25);
   15945                                 left(ios);
   15946                                 {
   15947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15948                                     std::string ex(str, iter.base());
   15949                                     assert(ex == "-0.000000****************");
   15950                                     assert(ios.width() == 0);
   15951                                 }
   15952                                 ios.width(25);
   15953                                 right(ios);
   15954                                 {
   15955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15956                                     std::string ex(str, iter.base());
   15957                                     assert(ex == "****************-0.000000");
   15958                                     assert(ios.width() == 0);
   15959                                 }
   15960                                 ios.width(25);
   15961                                 internal(ios);
   15962                                 {
   15963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15964                                     std::string ex(str, iter.base());
   15965                                     assert(ex == "-****************0.000000");
   15966                                     assert(ios.width() == 0);
   15967                                 }
   15968                             }
   15969                             ios.imbue(lg);
   15970                             {
   15971                                 ios.width(0);
   15972                                 {
   15973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15974                                     std::string ex(str, iter.base());
   15975                                     assert(ex == "-0;000000");
   15976                                     assert(ios.width() == 0);
   15977                                 }
   15978                                 ios.width(25);
   15979                                 left(ios);
   15980                                 {
   15981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15982                                     std::string ex(str, iter.base());
   15983                                     assert(ex == "-0;000000****************");
   15984                                     assert(ios.width() == 0);
   15985                                 }
   15986                                 ios.width(25);
   15987                                 right(ios);
   15988                                 {
   15989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15990                                     std::string ex(str, iter.base());
   15991                                     assert(ex == "****************-0;000000");
   15992                                     assert(ios.width() == 0);
   15993                                 }
   15994                                 ios.width(25);
   15995                                 internal(ios);
   15996                                 {
   15997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   15998                                     std::string ex(str, iter.base());
   15999                                     assert(ex == "-****************0;000000");
   16000                                     assert(ios.width() == 0);
   16001                                 }
   16002                             }
   16003                         }
   16004                         showpoint(ios);
   16005                         {
   16006                             ios.imbue(lc);
   16007                             {
   16008                                 ios.width(0);
   16009                                 {
   16010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16011                                     std::string ex(str, iter.base());
   16012                                     assert(ex == "-0.000000");
   16013                                     assert(ios.width() == 0);
   16014                                 }
   16015                                 ios.width(25);
   16016                                 left(ios);
   16017                                 {
   16018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16019                                     std::string ex(str, iter.base());
   16020                                     assert(ex == "-0.000000****************");
   16021                                     assert(ios.width() == 0);
   16022                                 }
   16023                                 ios.width(25);
   16024                                 right(ios);
   16025                                 {
   16026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16027                                     std::string ex(str, iter.base());
   16028                                     assert(ex == "****************-0.000000");
   16029                                     assert(ios.width() == 0);
   16030                                 }
   16031                                 ios.width(25);
   16032                                 internal(ios);
   16033                                 {
   16034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16035                                     std::string ex(str, iter.base());
   16036                                     assert(ex == "-****************0.000000");
   16037                                     assert(ios.width() == 0);
   16038                                 }
   16039                             }
   16040                             ios.imbue(lg);
   16041                             {
   16042                                 ios.width(0);
   16043                                 {
   16044                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16045                                     std::string ex(str, iter.base());
   16046                                     assert(ex == "-0;000000");
   16047                                     assert(ios.width() == 0);
   16048                                 }
   16049                                 ios.width(25);
   16050                                 left(ios);
   16051                                 {
   16052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16053                                     std::string ex(str, iter.base());
   16054                                     assert(ex == "-0;000000****************");
   16055                                     assert(ios.width() == 0);
   16056                                 }
   16057                                 ios.width(25);
   16058                                 right(ios);
   16059                                 {
   16060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16061                                     std::string ex(str, iter.base());
   16062                                     assert(ex == "****************-0;000000");
   16063                                     assert(ios.width() == 0);
   16064                                 }
   16065                                 ios.width(25);
   16066                                 internal(ios);
   16067                                 {
   16068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16069                                     std::string ex(str, iter.base());
   16070                                     assert(ex == "-****************0;000000");
   16071                                     assert(ios.width() == 0);
   16072                                 }
   16073                             }
   16074                         }
   16075                     }
   16076                 }
   16077             }
   16078             ios.precision(16);
   16079             {
   16080                 nouppercase(ios);
   16081                 {
   16082                     noshowpos(ios);
   16083                     {
   16084                         noshowpoint(ios);
   16085                         {
   16086                             ios.imbue(lc);
   16087                             {
   16088                                 ios.width(0);
   16089                                 {
   16090                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16091                                     std::string ex(str, iter.base());
   16092                                     assert(ex == "-0.0000000000000000");
   16093                                     assert(ios.width() == 0);
   16094                                 }
   16095                                 ios.width(25);
   16096                                 left(ios);
   16097                                 {
   16098                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16099                                     std::string ex(str, iter.base());
   16100                                     assert(ex == "-0.0000000000000000******");
   16101                                     assert(ios.width() == 0);
   16102                                 }
   16103                                 ios.width(25);
   16104                                 right(ios);
   16105                                 {
   16106                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16107                                     std::string ex(str, iter.base());
   16108                                     assert(ex == "******-0.0000000000000000");
   16109                                     assert(ios.width() == 0);
   16110                                 }
   16111                                 ios.width(25);
   16112                                 internal(ios);
   16113                                 {
   16114                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16115                                     std::string ex(str, iter.base());
   16116                                     assert(ex == "-******0.0000000000000000");
   16117                                     assert(ios.width() == 0);
   16118                                 }
   16119                             }
   16120                             ios.imbue(lg);
   16121                             {
   16122                                 ios.width(0);
   16123                                 {
   16124                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16125                                     std::string ex(str, iter.base());
   16126                                     assert(ex == "-0;0000000000000000");
   16127                                     assert(ios.width() == 0);
   16128                                 }
   16129                                 ios.width(25);
   16130                                 left(ios);
   16131                                 {
   16132                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16133                                     std::string ex(str, iter.base());
   16134                                     assert(ex == "-0;0000000000000000******");
   16135                                     assert(ios.width() == 0);
   16136                                 }
   16137                                 ios.width(25);
   16138                                 right(ios);
   16139                                 {
   16140                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16141                                     std::string ex(str, iter.base());
   16142                                     assert(ex == "******-0;0000000000000000");
   16143                                     assert(ios.width() == 0);
   16144                                 }
   16145                                 ios.width(25);
   16146                                 internal(ios);
   16147                                 {
   16148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16149                                     std::string ex(str, iter.base());
   16150                                     assert(ex == "-******0;0000000000000000");
   16151                                     assert(ios.width() == 0);
   16152                                 }
   16153                             }
   16154                         }
   16155                         showpoint(ios);
   16156                         {
   16157                             ios.imbue(lc);
   16158                             {
   16159                                 ios.width(0);
   16160                                 {
   16161                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16162                                     std::string ex(str, iter.base());
   16163                                     assert(ex == "-0.0000000000000000");
   16164                                     assert(ios.width() == 0);
   16165                                 }
   16166                                 ios.width(25);
   16167                                 left(ios);
   16168                                 {
   16169                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16170                                     std::string ex(str, iter.base());
   16171                                     assert(ex == "-0.0000000000000000******");
   16172                                     assert(ios.width() == 0);
   16173                                 }
   16174                                 ios.width(25);
   16175                                 right(ios);
   16176                                 {
   16177                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16178                                     std::string ex(str, iter.base());
   16179                                     assert(ex == "******-0.0000000000000000");
   16180                                     assert(ios.width() == 0);
   16181                                 }
   16182                                 ios.width(25);
   16183                                 internal(ios);
   16184                                 {
   16185                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16186                                     std::string ex(str, iter.base());
   16187                                     assert(ex == "-******0.0000000000000000");
   16188                                     assert(ios.width() == 0);
   16189                                 }
   16190                             }
   16191                             ios.imbue(lg);
   16192                             {
   16193                                 ios.width(0);
   16194                                 {
   16195                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16196                                     std::string ex(str, iter.base());
   16197                                     assert(ex == "-0;0000000000000000");
   16198                                     assert(ios.width() == 0);
   16199                                 }
   16200                                 ios.width(25);
   16201                                 left(ios);
   16202                                 {
   16203                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16204                                     std::string ex(str, iter.base());
   16205                                     assert(ex == "-0;0000000000000000******");
   16206                                     assert(ios.width() == 0);
   16207                                 }
   16208                                 ios.width(25);
   16209                                 right(ios);
   16210                                 {
   16211                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16212                                     std::string ex(str, iter.base());
   16213                                     assert(ex == "******-0;0000000000000000");
   16214                                     assert(ios.width() == 0);
   16215                                 }
   16216                                 ios.width(25);
   16217                                 internal(ios);
   16218                                 {
   16219                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16220                                     std::string ex(str, iter.base());
   16221                                     assert(ex == "-******0;0000000000000000");
   16222                                     assert(ios.width() == 0);
   16223                                 }
   16224                             }
   16225                         }
   16226                     }
   16227                     showpos(ios);
   16228                     {
   16229                         noshowpoint(ios);
   16230                         {
   16231                             ios.imbue(lc);
   16232                             {
   16233                                 ios.width(0);
   16234                                 {
   16235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16236                                     std::string ex(str, iter.base());
   16237                                     assert(ex == "-0.0000000000000000");
   16238                                     assert(ios.width() == 0);
   16239                                 }
   16240                                 ios.width(25);
   16241                                 left(ios);
   16242                                 {
   16243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16244                                     std::string ex(str, iter.base());
   16245                                     assert(ex == "-0.0000000000000000******");
   16246                                     assert(ios.width() == 0);
   16247                                 }
   16248                                 ios.width(25);
   16249                                 right(ios);
   16250                                 {
   16251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16252                                     std::string ex(str, iter.base());
   16253                                     assert(ex == "******-0.0000000000000000");
   16254                                     assert(ios.width() == 0);
   16255                                 }
   16256                                 ios.width(25);
   16257                                 internal(ios);
   16258                                 {
   16259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16260                                     std::string ex(str, iter.base());
   16261                                     assert(ex == "-******0.0000000000000000");
   16262                                     assert(ios.width() == 0);
   16263                                 }
   16264                             }
   16265                             ios.imbue(lg);
   16266                             {
   16267                                 ios.width(0);
   16268                                 {
   16269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16270                                     std::string ex(str, iter.base());
   16271                                     assert(ex == "-0;0000000000000000");
   16272                                     assert(ios.width() == 0);
   16273                                 }
   16274                                 ios.width(25);
   16275                                 left(ios);
   16276                                 {
   16277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16278                                     std::string ex(str, iter.base());
   16279                                     assert(ex == "-0;0000000000000000******");
   16280                                     assert(ios.width() == 0);
   16281                                 }
   16282                                 ios.width(25);
   16283                                 right(ios);
   16284                                 {
   16285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16286                                     std::string ex(str, iter.base());
   16287                                     assert(ex == "******-0;0000000000000000");
   16288                                     assert(ios.width() == 0);
   16289                                 }
   16290                                 ios.width(25);
   16291                                 internal(ios);
   16292                                 {
   16293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16294                                     std::string ex(str, iter.base());
   16295                                     assert(ex == "-******0;0000000000000000");
   16296                                     assert(ios.width() == 0);
   16297                                 }
   16298                             }
   16299                         }
   16300                         showpoint(ios);
   16301                         {
   16302                             ios.imbue(lc);
   16303                             {
   16304                                 ios.width(0);
   16305                                 {
   16306                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16307                                     std::string ex(str, iter.base());
   16308                                     assert(ex == "-0.0000000000000000");
   16309                                     assert(ios.width() == 0);
   16310                                 }
   16311                                 ios.width(25);
   16312                                 left(ios);
   16313                                 {
   16314                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16315                                     std::string ex(str, iter.base());
   16316                                     assert(ex == "-0.0000000000000000******");
   16317                                     assert(ios.width() == 0);
   16318                                 }
   16319                                 ios.width(25);
   16320                                 right(ios);
   16321                                 {
   16322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16323                                     std::string ex(str, iter.base());
   16324                                     assert(ex == "******-0.0000000000000000");
   16325                                     assert(ios.width() == 0);
   16326                                 }
   16327                                 ios.width(25);
   16328                                 internal(ios);
   16329                                 {
   16330                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16331                                     std::string ex(str, iter.base());
   16332                                     assert(ex == "-******0.0000000000000000");
   16333                                     assert(ios.width() == 0);
   16334                                 }
   16335                             }
   16336                             ios.imbue(lg);
   16337                             {
   16338                                 ios.width(0);
   16339                                 {
   16340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16341                                     std::string ex(str, iter.base());
   16342                                     assert(ex == "-0;0000000000000000");
   16343                                     assert(ios.width() == 0);
   16344                                 }
   16345                                 ios.width(25);
   16346                                 left(ios);
   16347                                 {
   16348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16349                                     std::string ex(str, iter.base());
   16350                                     assert(ex == "-0;0000000000000000******");
   16351                                     assert(ios.width() == 0);
   16352                                 }
   16353                                 ios.width(25);
   16354                                 right(ios);
   16355                                 {
   16356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16357                                     std::string ex(str, iter.base());
   16358                                     assert(ex == "******-0;0000000000000000");
   16359                                     assert(ios.width() == 0);
   16360                                 }
   16361                                 ios.width(25);
   16362                                 internal(ios);
   16363                                 {
   16364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16365                                     std::string ex(str, iter.base());
   16366                                     assert(ex == "-******0;0000000000000000");
   16367                                     assert(ios.width() == 0);
   16368                                 }
   16369                             }
   16370                         }
   16371                     }
   16372                 }
   16373                 uppercase(ios);
   16374                 {
   16375                     noshowpos(ios);
   16376                     {
   16377                         noshowpoint(ios);
   16378                         {
   16379                             ios.imbue(lc);
   16380                             {
   16381                                 ios.width(0);
   16382                                 {
   16383                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16384                                     std::string ex(str, iter.base());
   16385                                     assert(ex == "-0.0000000000000000");
   16386                                     assert(ios.width() == 0);
   16387                                 }
   16388                                 ios.width(25);
   16389                                 left(ios);
   16390                                 {
   16391                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16392                                     std::string ex(str, iter.base());
   16393                                     assert(ex == "-0.0000000000000000******");
   16394                                     assert(ios.width() == 0);
   16395                                 }
   16396                                 ios.width(25);
   16397                                 right(ios);
   16398                                 {
   16399                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16400                                     std::string ex(str, iter.base());
   16401                                     assert(ex == "******-0.0000000000000000");
   16402                                     assert(ios.width() == 0);
   16403                                 }
   16404                                 ios.width(25);
   16405                                 internal(ios);
   16406                                 {
   16407                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16408                                     std::string ex(str, iter.base());
   16409                                     assert(ex == "-******0.0000000000000000");
   16410                                     assert(ios.width() == 0);
   16411                                 }
   16412                             }
   16413                             ios.imbue(lg);
   16414                             {
   16415                                 ios.width(0);
   16416                                 {
   16417                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16418                                     std::string ex(str, iter.base());
   16419                                     assert(ex == "-0;0000000000000000");
   16420                                     assert(ios.width() == 0);
   16421                                 }
   16422                                 ios.width(25);
   16423                                 left(ios);
   16424                                 {
   16425                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16426                                     std::string ex(str, iter.base());
   16427                                     assert(ex == "-0;0000000000000000******");
   16428                                     assert(ios.width() == 0);
   16429                                 }
   16430                                 ios.width(25);
   16431                                 right(ios);
   16432                                 {
   16433                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16434                                     std::string ex(str, iter.base());
   16435                                     assert(ex == "******-0;0000000000000000");
   16436                                     assert(ios.width() == 0);
   16437                                 }
   16438                                 ios.width(25);
   16439                                 internal(ios);
   16440                                 {
   16441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16442                                     std::string ex(str, iter.base());
   16443                                     assert(ex == "-******0;0000000000000000");
   16444                                     assert(ios.width() == 0);
   16445                                 }
   16446                             }
   16447                         }
   16448                         showpoint(ios);
   16449                         {
   16450                             ios.imbue(lc);
   16451                             {
   16452                                 ios.width(0);
   16453                                 {
   16454                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16455                                     std::string ex(str, iter.base());
   16456                                     assert(ex == "-0.0000000000000000");
   16457                                     assert(ios.width() == 0);
   16458                                 }
   16459                                 ios.width(25);
   16460                                 left(ios);
   16461                                 {
   16462                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16463                                     std::string ex(str, iter.base());
   16464                                     assert(ex == "-0.0000000000000000******");
   16465                                     assert(ios.width() == 0);
   16466                                 }
   16467                                 ios.width(25);
   16468                                 right(ios);
   16469                                 {
   16470                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16471                                     std::string ex(str, iter.base());
   16472                                     assert(ex == "******-0.0000000000000000");
   16473                                     assert(ios.width() == 0);
   16474                                 }
   16475                                 ios.width(25);
   16476                                 internal(ios);
   16477                                 {
   16478                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16479                                     std::string ex(str, iter.base());
   16480                                     assert(ex == "-******0.0000000000000000");
   16481                                     assert(ios.width() == 0);
   16482                                 }
   16483                             }
   16484                             ios.imbue(lg);
   16485                             {
   16486                                 ios.width(0);
   16487                                 {
   16488                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16489                                     std::string ex(str, iter.base());
   16490                                     assert(ex == "-0;0000000000000000");
   16491                                     assert(ios.width() == 0);
   16492                                 }
   16493                                 ios.width(25);
   16494                                 left(ios);
   16495                                 {
   16496                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16497                                     std::string ex(str, iter.base());
   16498                                     assert(ex == "-0;0000000000000000******");
   16499                                     assert(ios.width() == 0);
   16500                                 }
   16501                                 ios.width(25);
   16502                                 right(ios);
   16503                                 {
   16504                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16505                                     std::string ex(str, iter.base());
   16506                                     assert(ex == "******-0;0000000000000000");
   16507                                     assert(ios.width() == 0);
   16508                                 }
   16509                                 ios.width(25);
   16510                                 internal(ios);
   16511                                 {
   16512                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16513                                     std::string ex(str, iter.base());
   16514                                     assert(ex == "-******0;0000000000000000");
   16515                                     assert(ios.width() == 0);
   16516                                 }
   16517                             }
   16518                         }
   16519                     }
   16520                     showpos(ios);
   16521                     {
   16522                         noshowpoint(ios);
   16523                         {
   16524                             ios.imbue(lc);
   16525                             {
   16526                                 ios.width(0);
   16527                                 {
   16528                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16529                                     std::string ex(str, iter.base());
   16530                                     assert(ex == "-0.0000000000000000");
   16531                                     assert(ios.width() == 0);
   16532                                 }
   16533                                 ios.width(25);
   16534                                 left(ios);
   16535                                 {
   16536                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16537                                     std::string ex(str, iter.base());
   16538                                     assert(ex == "-0.0000000000000000******");
   16539                                     assert(ios.width() == 0);
   16540                                 }
   16541                                 ios.width(25);
   16542                                 right(ios);
   16543                                 {
   16544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16545                                     std::string ex(str, iter.base());
   16546                                     assert(ex == "******-0.0000000000000000");
   16547                                     assert(ios.width() == 0);
   16548                                 }
   16549                                 ios.width(25);
   16550                                 internal(ios);
   16551                                 {
   16552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16553                                     std::string ex(str, iter.base());
   16554                                     assert(ex == "-******0.0000000000000000");
   16555                                     assert(ios.width() == 0);
   16556                                 }
   16557                             }
   16558                             ios.imbue(lg);
   16559                             {
   16560                                 ios.width(0);
   16561                                 {
   16562                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16563                                     std::string ex(str, iter.base());
   16564                                     assert(ex == "-0;0000000000000000");
   16565                                     assert(ios.width() == 0);
   16566                                 }
   16567                                 ios.width(25);
   16568                                 left(ios);
   16569                                 {
   16570                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16571                                     std::string ex(str, iter.base());
   16572                                     assert(ex == "-0;0000000000000000******");
   16573                                     assert(ios.width() == 0);
   16574                                 }
   16575                                 ios.width(25);
   16576                                 right(ios);
   16577                                 {
   16578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16579                                     std::string ex(str, iter.base());
   16580                                     assert(ex == "******-0;0000000000000000");
   16581                                     assert(ios.width() == 0);
   16582                                 }
   16583                                 ios.width(25);
   16584                                 internal(ios);
   16585                                 {
   16586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16587                                     std::string ex(str, iter.base());
   16588                                     assert(ex == "-******0;0000000000000000");
   16589                                     assert(ios.width() == 0);
   16590                                 }
   16591                             }
   16592                         }
   16593                         showpoint(ios);
   16594                         {
   16595                             ios.imbue(lc);
   16596                             {
   16597                                 ios.width(0);
   16598                                 {
   16599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16600                                     std::string ex(str, iter.base());
   16601                                     assert(ex == "-0.0000000000000000");
   16602                                     assert(ios.width() == 0);
   16603                                 }
   16604                                 ios.width(25);
   16605                                 left(ios);
   16606                                 {
   16607                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16608                                     std::string ex(str, iter.base());
   16609                                     assert(ex == "-0.0000000000000000******");
   16610                                     assert(ios.width() == 0);
   16611                                 }
   16612                                 ios.width(25);
   16613                                 right(ios);
   16614                                 {
   16615                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16616                                     std::string ex(str, iter.base());
   16617                                     assert(ex == "******-0.0000000000000000");
   16618                                     assert(ios.width() == 0);
   16619                                 }
   16620                                 ios.width(25);
   16621                                 internal(ios);
   16622                                 {
   16623                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16624                                     std::string ex(str, iter.base());
   16625                                     assert(ex == "-******0.0000000000000000");
   16626                                     assert(ios.width() == 0);
   16627                                 }
   16628                             }
   16629                             ios.imbue(lg);
   16630                             {
   16631                                 ios.width(0);
   16632                                 {
   16633                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16634                                     std::string ex(str, iter.base());
   16635                                     assert(ex == "-0;0000000000000000");
   16636                                     assert(ios.width() == 0);
   16637                                 }
   16638                                 ios.width(25);
   16639                                 left(ios);
   16640                                 {
   16641                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16642                                     std::string ex(str, iter.base());
   16643                                     assert(ex == "-0;0000000000000000******");
   16644                                     assert(ios.width() == 0);
   16645                                 }
   16646                                 ios.width(25);
   16647                                 right(ios);
   16648                                 {
   16649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16650                                     std::string ex(str, iter.base());
   16651                                     assert(ex == "******-0;0000000000000000");
   16652                                     assert(ios.width() == 0);
   16653                                 }
   16654                                 ios.width(25);
   16655                                 internal(ios);
   16656                                 {
   16657                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16658                                     std::string ex(str, iter.base());
   16659                                     assert(ex == "-******0;0000000000000000");
   16660                                     assert(ios.width() == 0);
   16661                                 }
   16662                             }
   16663                         }
   16664                     }
   16665                 }
   16666             }
   16667             ios.precision(60);
   16668             {
   16669                 nouppercase(ios);
   16670                 {
   16671                     noshowpos(ios);
   16672                     {
   16673                         noshowpoint(ios);
   16674                         {
   16675                             ios.imbue(lc);
   16676                             {
   16677                                 ios.width(0);
   16678                                 {
   16679                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16680                                     std::string ex(str, iter.base());
   16681                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16682                                     assert(ios.width() == 0);
   16683                                 }
   16684                                 ios.width(25);
   16685                                 left(ios);
   16686                                 {
   16687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16688                                     std::string ex(str, iter.base());
   16689                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16690                                     assert(ios.width() == 0);
   16691                                 }
   16692                                 ios.width(25);
   16693                                 right(ios);
   16694                                 {
   16695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16696                                     std::string ex(str, iter.base());
   16697                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16698                                     assert(ios.width() == 0);
   16699                                 }
   16700                                 ios.width(25);
   16701                                 internal(ios);
   16702                                 {
   16703                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16704                                     std::string ex(str, iter.base());
   16705                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16706                                     assert(ios.width() == 0);
   16707                                 }
   16708                             }
   16709                             ios.imbue(lg);
   16710                             {
   16711                                 ios.width(0);
   16712                                 {
   16713                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16714                                     std::string ex(str, iter.base());
   16715                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16716                                     assert(ios.width() == 0);
   16717                                 }
   16718                                 ios.width(25);
   16719                                 left(ios);
   16720                                 {
   16721                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16722                                     std::string ex(str, iter.base());
   16723                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16724                                     assert(ios.width() == 0);
   16725                                 }
   16726                                 ios.width(25);
   16727                                 right(ios);
   16728                                 {
   16729                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16730                                     std::string ex(str, iter.base());
   16731                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16732                                     assert(ios.width() == 0);
   16733                                 }
   16734                                 ios.width(25);
   16735                                 internal(ios);
   16736                                 {
   16737                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16738                                     std::string ex(str, iter.base());
   16739                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16740                                     assert(ios.width() == 0);
   16741                                 }
   16742                             }
   16743                         }
   16744                         showpoint(ios);
   16745                         {
   16746                             ios.imbue(lc);
   16747                             {
   16748                                 ios.width(0);
   16749                                 {
   16750                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16751                                     std::string ex(str, iter.base());
   16752                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16753                                     assert(ios.width() == 0);
   16754                                 }
   16755                                 ios.width(25);
   16756                                 left(ios);
   16757                                 {
   16758                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16759                                     std::string ex(str, iter.base());
   16760                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16761                                     assert(ios.width() == 0);
   16762                                 }
   16763                                 ios.width(25);
   16764                                 right(ios);
   16765                                 {
   16766                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16767                                     std::string ex(str, iter.base());
   16768                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16769                                     assert(ios.width() == 0);
   16770                                 }
   16771                                 ios.width(25);
   16772                                 internal(ios);
   16773                                 {
   16774                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16775                                     std::string ex(str, iter.base());
   16776                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16777                                     assert(ios.width() == 0);
   16778                                 }
   16779                             }
   16780                             ios.imbue(lg);
   16781                             {
   16782                                 ios.width(0);
   16783                                 {
   16784                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16785                                     std::string ex(str, iter.base());
   16786                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16787                                     assert(ios.width() == 0);
   16788                                 }
   16789                                 ios.width(25);
   16790                                 left(ios);
   16791                                 {
   16792                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16793                                     std::string ex(str, iter.base());
   16794                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16795                                     assert(ios.width() == 0);
   16796                                 }
   16797                                 ios.width(25);
   16798                                 right(ios);
   16799                                 {
   16800                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16801                                     std::string ex(str, iter.base());
   16802                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16803                                     assert(ios.width() == 0);
   16804                                 }
   16805                                 ios.width(25);
   16806                                 internal(ios);
   16807                                 {
   16808                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16809                                     std::string ex(str, iter.base());
   16810                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16811                                     assert(ios.width() == 0);
   16812                                 }
   16813                             }
   16814                         }
   16815                     }
   16816                     showpos(ios);
   16817                     {
   16818                         noshowpoint(ios);
   16819                         {
   16820                             ios.imbue(lc);
   16821                             {
   16822                                 ios.width(0);
   16823                                 {
   16824                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16825                                     std::string ex(str, iter.base());
   16826                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16827                                     assert(ios.width() == 0);
   16828                                 }
   16829                                 ios.width(25);
   16830                                 left(ios);
   16831                                 {
   16832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16833                                     std::string ex(str, iter.base());
   16834                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16835                                     assert(ios.width() == 0);
   16836                                 }
   16837                                 ios.width(25);
   16838                                 right(ios);
   16839                                 {
   16840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16841                                     std::string ex(str, iter.base());
   16842                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16843                                     assert(ios.width() == 0);
   16844                                 }
   16845                                 ios.width(25);
   16846                                 internal(ios);
   16847                                 {
   16848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16849                                     std::string ex(str, iter.base());
   16850                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16851                                     assert(ios.width() == 0);
   16852                                 }
   16853                             }
   16854                             ios.imbue(lg);
   16855                             {
   16856                                 ios.width(0);
   16857                                 {
   16858                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16859                                     std::string ex(str, iter.base());
   16860                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16861                                     assert(ios.width() == 0);
   16862                                 }
   16863                                 ios.width(25);
   16864                                 left(ios);
   16865                                 {
   16866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16867                                     std::string ex(str, iter.base());
   16868                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16869                                     assert(ios.width() == 0);
   16870                                 }
   16871                                 ios.width(25);
   16872                                 right(ios);
   16873                                 {
   16874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16875                                     std::string ex(str, iter.base());
   16876                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16877                                     assert(ios.width() == 0);
   16878                                 }
   16879                                 ios.width(25);
   16880                                 internal(ios);
   16881                                 {
   16882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16883                                     std::string ex(str, iter.base());
   16884                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16885                                     assert(ios.width() == 0);
   16886                                 }
   16887                             }
   16888                         }
   16889                         showpoint(ios);
   16890                         {
   16891                             ios.imbue(lc);
   16892                             {
   16893                                 ios.width(0);
   16894                                 {
   16895                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16896                                     std::string ex(str, iter.base());
   16897                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16898                                     assert(ios.width() == 0);
   16899                                 }
   16900                                 ios.width(25);
   16901                                 left(ios);
   16902                                 {
   16903                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16904                                     std::string ex(str, iter.base());
   16905                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16906                                     assert(ios.width() == 0);
   16907                                 }
   16908                                 ios.width(25);
   16909                                 right(ios);
   16910                                 {
   16911                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16912                                     std::string ex(str, iter.base());
   16913                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16914                                     assert(ios.width() == 0);
   16915                                 }
   16916                                 ios.width(25);
   16917                                 internal(ios);
   16918                                 {
   16919                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16920                                     std::string ex(str, iter.base());
   16921                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16922                                     assert(ios.width() == 0);
   16923                                 }
   16924                             }
   16925                             ios.imbue(lg);
   16926                             {
   16927                                 ios.width(0);
   16928                                 {
   16929                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16930                                     std::string ex(str, iter.base());
   16931                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16932                                     assert(ios.width() == 0);
   16933                                 }
   16934                                 ios.width(25);
   16935                                 left(ios);
   16936                                 {
   16937                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16938                                     std::string ex(str, iter.base());
   16939                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16940                                     assert(ios.width() == 0);
   16941                                 }
   16942                                 ios.width(25);
   16943                                 right(ios);
   16944                                 {
   16945                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16946                                     std::string ex(str, iter.base());
   16947                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16948                                     assert(ios.width() == 0);
   16949                                 }
   16950                                 ios.width(25);
   16951                                 internal(ios);
   16952                                 {
   16953                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16954                                     std::string ex(str, iter.base());
   16955                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   16956                                     assert(ios.width() == 0);
   16957                                 }
   16958                             }
   16959                         }
   16960                     }
   16961                 }
   16962                 uppercase(ios);
   16963                 {
   16964                     noshowpos(ios);
   16965                     {
   16966                         noshowpoint(ios);
   16967                         {
   16968                             ios.imbue(lc);
   16969                             {
   16970                                 ios.width(0);
   16971                                 {
   16972                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16973                                     std::string ex(str, iter.base());
   16974                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16975                                     assert(ios.width() == 0);
   16976                                 }
   16977                                 ios.width(25);
   16978                                 left(ios);
   16979                                 {
   16980                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16981                                     std::string ex(str, iter.base());
   16982                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16983                                     assert(ios.width() == 0);
   16984                                 }
   16985                                 ios.width(25);
   16986                                 right(ios);
   16987                                 {
   16988                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16989                                     std::string ex(str, iter.base());
   16990                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16991                                     assert(ios.width() == 0);
   16992                                 }
   16993                                 ios.width(25);
   16994                                 internal(ios);
   16995                                 {
   16996                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   16997                                     std::string ex(str, iter.base());
   16998                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   16999                                     assert(ios.width() == 0);
   17000                                 }
   17001                             }
   17002                             ios.imbue(lg);
   17003                             {
   17004                                 ios.width(0);
   17005                                 {
   17006                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17007                                     std::string ex(str, iter.base());
   17008                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17009                                     assert(ios.width() == 0);
   17010                                 }
   17011                                 ios.width(25);
   17012                                 left(ios);
   17013                                 {
   17014                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17015                                     std::string ex(str, iter.base());
   17016                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17017                                     assert(ios.width() == 0);
   17018                                 }
   17019                                 ios.width(25);
   17020                                 right(ios);
   17021                                 {
   17022                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17023                                     std::string ex(str, iter.base());
   17024                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17025                                     assert(ios.width() == 0);
   17026                                 }
   17027                                 ios.width(25);
   17028                                 internal(ios);
   17029                                 {
   17030                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17031                                     std::string ex(str, iter.base());
   17032                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17033                                     assert(ios.width() == 0);
   17034                                 }
   17035                             }
   17036                         }
   17037                         showpoint(ios);
   17038                         {
   17039                             ios.imbue(lc);
   17040                             {
   17041                                 ios.width(0);
   17042                                 {
   17043                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17044                                     std::string ex(str, iter.base());
   17045                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17046                                     assert(ios.width() == 0);
   17047                                 }
   17048                                 ios.width(25);
   17049                                 left(ios);
   17050                                 {
   17051                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17052                                     std::string ex(str, iter.base());
   17053                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17054                                     assert(ios.width() == 0);
   17055                                 }
   17056                                 ios.width(25);
   17057                                 right(ios);
   17058                                 {
   17059                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17060                                     std::string ex(str, iter.base());
   17061                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17062                                     assert(ios.width() == 0);
   17063                                 }
   17064                                 ios.width(25);
   17065                                 internal(ios);
   17066                                 {
   17067                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17068                                     std::string ex(str, iter.base());
   17069                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17070                                     assert(ios.width() == 0);
   17071                                 }
   17072                             }
   17073                             ios.imbue(lg);
   17074                             {
   17075                                 ios.width(0);
   17076                                 {
   17077                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17078                                     std::string ex(str, iter.base());
   17079                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17080                                     assert(ios.width() == 0);
   17081                                 }
   17082                                 ios.width(25);
   17083                                 left(ios);
   17084                                 {
   17085                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17086                                     std::string ex(str, iter.base());
   17087                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17088                                     assert(ios.width() == 0);
   17089                                 }
   17090                                 ios.width(25);
   17091                                 right(ios);
   17092                                 {
   17093                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17094                                     std::string ex(str, iter.base());
   17095                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17096                                     assert(ios.width() == 0);
   17097                                 }
   17098                                 ios.width(25);
   17099                                 internal(ios);
   17100                                 {
   17101                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17102                                     std::string ex(str, iter.base());
   17103                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17104                                     assert(ios.width() == 0);
   17105                                 }
   17106                             }
   17107                         }
   17108                     }
   17109                     showpos(ios);
   17110                     {
   17111                         noshowpoint(ios);
   17112                         {
   17113                             ios.imbue(lc);
   17114                             {
   17115                                 ios.width(0);
   17116                                 {
   17117                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17118                                     std::string ex(str, iter.base());
   17119                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17120                                     assert(ios.width() == 0);
   17121                                 }
   17122                                 ios.width(25);
   17123                                 left(ios);
   17124                                 {
   17125                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17126                                     std::string ex(str, iter.base());
   17127                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17128                                     assert(ios.width() == 0);
   17129                                 }
   17130                                 ios.width(25);
   17131                                 right(ios);
   17132                                 {
   17133                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17134                                     std::string ex(str, iter.base());
   17135                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17136                                     assert(ios.width() == 0);
   17137                                 }
   17138                                 ios.width(25);
   17139                                 internal(ios);
   17140                                 {
   17141                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17142                                     std::string ex(str, iter.base());
   17143                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17144                                     assert(ios.width() == 0);
   17145                                 }
   17146                             }
   17147                             ios.imbue(lg);
   17148                             {
   17149                                 ios.width(0);
   17150                                 {
   17151                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17152                                     std::string ex(str, iter.base());
   17153                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17154                                     assert(ios.width() == 0);
   17155                                 }
   17156                                 ios.width(25);
   17157                                 left(ios);
   17158                                 {
   17159                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17160                                     std::string ex(str, iter.base());
   17161                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17162                                     assert(ios.width() == 0);
   17163                                 }
   17164                                 ios.width(25);
   17165                                 right(ios);
   17166                                 {
   17167                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17168                                     std::string ex(str, iter.base());
   17169                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17170                                     assert(ios.width() == 0);
   17171                                 }
   17172                                 ios.width(25);
   17173                                 internal(ios);
   17174                                 {
   17175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17176                                     std::string ex(str, iter.base());
   17177                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17178                                     assert(ios.width() == 0);
   17179                                 }
   17180                             }
   17181                         }
   17182                         showpoint(ios);
   17183                         {
   17184                             ios.imbue(lc);
   17185                             {
   17186                                 ios.width(0);
   17187                                 {
   17188                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17189                                     std::string ex(str, iter.base());
   17190                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17191                                     assert(ios.width() == 0);
   17192                                 }
   17193                                 ios.width(25);
   17194                                 left(ios);
   17195                                 {
   17196                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17197                                     std::string ex(str, iter.base());
   17198                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17199                                     assert(ios.width() == 0);
   17200                                 }
   17201                                 ios.width(25);
   17202                                 right(ios);
   17203                                 {
   17204                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17205                                     std::string ex(str, iter.base());
   17206                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17207                                     assert(ios.width() == 0);
   17208                                 }
   17209                                 ios.width(25);
   17210                                 internal(ios);
   17211                                 {
   17212                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17213                                     std::string ex(str, iter.base());
   17214                                     assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000");
   17215                                     assert(ios.width() == 0);
   17216                                 }
   17217                             }
   17218                             ios.imbue(lg);
   17219                             {
   17220                                 ios.width(0);
   17221                                 {
   17222                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17223                                     std::string ex(str, iter.base());
   17224                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17225                                     assert(ios.width() == 0);
   17226                                 }
   17227                                 ios.width(25);
   17228                                 left(ios);
   17229                                 {
   17230                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17231                                     std::string ex(str, iter.base());
   17232                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17233                                     assert(ios.width() == 0);
   17234                                 }
   17235                                 ios.width(25);
   17236                                 right(ios);
   17237                                 {
   17238                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17239                                     std::string ex(str, iter.base());
   17240                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17241                                     assert(ios.width() == 0);
   17242                                 }
   17243                                 ios.width(25);
   17244                                 internal(ios);
   17245                                 {
   17246                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17247                                     std::string ex(str, iter.base());
   17248                                     assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000");
   17249                                     assert(ios.width() == 0);
   17250                                 }
   17251                             }
   17252                         }
   17253                     }
   17254                 }
   17255             }
   17256         }
   17257     }
   17258 }
   17259 
   17260 void test8()
   17261 {
   17262     char str[200];
   17263     output_iterator<char*> iter;
   17264     std::locale lc = std::locale::classic();
   17265     std::locale lg(lc, new my_numpunct);
   17266     const my_facet f(1);
   17267     {
   17268         long double v = 1234567890.125;
   17269         std::ios ios(0);
   17270         fixed(ios);
   17271         // %f
   17272         {
   17273             ios.precision(0);
   17274             {
   17275                 nouppercase(ios);
   17276                 {
   17277                     noshowpos(ios);
   17278                     {
   17279                         noshowpoint(ios);
   17280                         {
   17281                             ios.imbue(lc);
   17282                             {
   17283                                 ios.width(0);
   17284                                 {
   17285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17286                                     std::string ex(str, iter.base());
   17287                                     assert(ex == "1234567890");
   17288                                     assert(ios.width() == 0);
   17289                                 }
   17290                                 ios.width(25);
   17291                                 left(ios);
   17292                                 {
   17293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17294                                     std::string ex(str, iter.base());
   17295                                     assert(ex == "1234567890***************");
   17296                                     assert(ios.width() == 0);
   17297                                 }
   17298                                 ios.width(25);
   17299                                 right(ios);
   17300                                 {
   17301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17302                                     std::string ex(str, iter.base());
   17303                                     assert(ex == "***************1234567890");
   17304                                     assert(ios.width() == 0);
   17305                                 }
   17306                                 ios.width(25);
   17307                                 internal(ios);
   17308                                 {
   17309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17310                                     std::string ex(str, iter.base());
   17311                                     assert(ex == "***************1234567890");
   17312                                     assert(ios.width() == 0);
   17313                                 }
   17314                             }
   17315                             ios.imbue(lg);
   17316                             {
   17317                                 ios.width(0);
   17318                                 {
   17319                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17320                                     std::string ex(str, iter.base());
   17321                                     assert(ex == "1_234_567_89_0");
   17322                                     assert(ios.width() == 0);
   17323                                 }
   17324                                 ios.width(25);
   17325                                 left(ios);
   17326                                 {
   17327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17328                                     std::string ex(str, iter.base());
   17329                                     assert(ex == "1_234_567_89_0***********");
   17330                                     assert(ios.width() == 0);
   17331                                 }
   17332                                 ios.width(25);
   17333                                 right(ios);
   17334                                 {
   17335                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17336                                     std::string ex(str, iter.base());
   17337                                     assert(ex == "***********1_234_567_89_0");
   17338                                     assert(ios.width() == 0);
   17339                                 }
   17340                                 ios.width(25);
   17341                                 internal(ios);
   17342                                 {
   17343                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17344                                     std::string ex(str, iter.base());
   17345                                     assert(ex == "***********1_234_567_89_0");
   17346                                     assert(ios.width() == 0);
   17347                                 }
   17348                             }
   17349                         }
   17350                         showpoint(ios);
   17351                         {
   17352                             ios.imbue(lc);
   17353                             {
   17354                                 ios.width(0);
   17355                                 {
   17356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17357                                     std::string ex(str, iter.base());
   17358                                     assert(ex == "1234567890.");
   17359                                     assert(ios.width() == 0);
   17360                                 }
   17361                                 ios.width(25);
   17362                                 left(ios);
   17363                                 {
   17364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17365                                     std::string ex(str, iter.base());
   17366                                     assert(ex == "1234567890.**************");
   17367                                     assert(ios.width() == 0);
   17368                                 }
   17369                                 ios.width(25);
   17370                                 right(ios);
   17371                                 {
   17372                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17373                                     std::string ex(str, iter.base());
   17374                                     assert(ex == "**************1234567890.");
   17375                                     assert(ios.width() == 0);
   17376                                 }
   17377                                 ios.width(25);
   17378                                 internal(ios);
   17379                                 {
   17380                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17381                                     std::string ex(str, iter.base());
   17382                                     assert(ex == "**************1234567890.");
   17383                                     assert(ios.width() == 0);
   17384                                 }
   17385                             }
   17386                             ios.imbue(lg);
   17387                             {
   17388                                 ios.width(0);
   17389                                 {
   17390                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17391                                     std::string ex(str, iter.base());
   17392                                     assert(ex == "1_234_567_89_0;");
   17393                                     assert(ios.width() == 0);
   17394                                 }
   17395                                 ios.width(25);
   17396                                 left(ios);
   17397                                 {
   17398                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17399                                     std::string ex(str, iter.base());
   17400                                     assert(ex == "1_234_567_89_0;**********");
   17401                                     assert(ios.width() == 0);
   17402                                 }
   17403                                 ios.width(25);
   17404                                 right(ios);
   17405                                 {
   17406                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17407                                     std::string ex(str, iter.base());
   17408                                     assert(ex == "**********1_234_567_89_0;");
   17409                                     assert(ios.width() == 0);
   17410                                 }
   17411                                 ios.width(25);
   17412                                 internal(ios);
   17413                                 {
   17414                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17415                                     std::string ex(str, iter.base());
   17416                                     assert(ex == "**********1_234_567_89_0;");
   17417                                     assert(ios.width() == 0);
   17418                                 }
   17419                             }
   17420                         }
   17421                     }
   17422                     showpos(ios);
   17423                     {
   17424                         noshowpoint(ios);
   17425                         {
   17426                             ios.imbue(lc);
   17427                             {
   17428                                 ios.width(0);
   17429                                 {
   17430                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17431                                     std::string ex(str, iter.base());
   17432                                     assert(ex == "+1234567890");
   17433                                     assert(ios.width() == 0);
   17434                                 }
   17435                                 ios.width(25);
   17436                                 left(ios);
   17437                                 {
   17438                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17439                                     std::string ex(str, iter.base());
   17440                                     assert(ex == "+1234567890**************");
   17441                                     assert(ios.width() == 0);
   17442                                 }
   17443                                 ios.width(25);
   17444                                 right(ios);
   17445                                 {
   17446                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17447                                     std::string ex(str, iter.base());
   17448                                     assert(ex == "**************+1234567890");
   17449                                     assert(ios.width() == 0);
   17450                                 }
   17451                                 ios.width(25);
   17452                                 internal(ios);
   17453                                 {
   17454                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17455                                     std::string ex(str, iter.base());
   17456                                     assert(ex == "+**************1234567890");
   17457                                     assert(ios.width() == 0);
   17458                                 }
   17459                             }
   17460                             ios.imbue(lg);
   17461                             {
   17462                                 ios.width(0);
   17463                                 {
   17464                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17465                                     std::string ex(str, iter.base());
   17466                                     assert(ex == "+1_234_567_89_0");
   17467                                     assert(ios.width() == 0);
   17468                                 }
   17469                                 ios.width(25);
   17470                                 left(ios);
   17471                                 {
   17472                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17473                                     std::string ex(str, iter.base());
   17474                                     assert(ex == "+1_234_567_89_0**********");
   17475                                     assert(ios.width() == 0);
   17476                                 }
   17477                                 ios.width(25);
   17478                                 right(ios);
   17479                                 {
   17480                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17481                                     std::string ex(str, iter.base());
   17482                                     assert(ex == "**********+1_234_567_89_0");
   17483                                     assert(ios.width() == 0);
   17484                                 }
   17485                                 ios.width(25);
   17486                                 internal(ios);
   17487                                 {
   17488                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17489                                     std::string ex(str, iter.base());
   17490                                     assert(ex == "+**********1_234_567_89_0");
   17491                                     assert(ios.width() == 0);
   17492                                 }
   17493                             }
   17494                         }
   17495                         showpoint(ios);
   17496                         {
   17497                             ios.imbue(lc);
   17498                             {
   17499                                 ios.width(0);
   17500                                 {
   17501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17502                                     std::string ex(str, iter.base());
   17503                                     assert(ex == "+1234567890.");
   17504                                     assert(ios.width() == 0);
   17505                                 }
   17506                                 ios.width(25);
   17507                                 left(ios);
   17508                                 {
   17509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17510                                     std::string ex(str, iter.base());
   17511                                     assert(ex == "+1234567890.*************");
   17512                                     assert(ios.width() == 0);
   17513                                 }
   17514                                 ios.width(25);
   17515                                 right(ios);
   17516                                 {
   17517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17518                                     std::string ex(str, iter.base());
   17519                                     assert(ex == "*************+1234567890.");
   17520                                     assert(ios.width() == 0);
   17521                                 }
   17522                                 ios.width(25);
   17523                                 internal(ios);
   17524                                 {
   17525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17526                                     std::string ex(str, iter.base());
   17527                                     assert(ex == "+*************1234567890.");
   17528                                     assert(ios.width() == 0);
   17529                                 }
   17530                             }
   17531                             ios.imbue(lg);
   17532                             {
   17533                                 ios.width(0);
   17534                                 {
   17535                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17536                                     std::string ex(str, iter.base());
   17537                                     assert(ex == "+1_234_567_89_0;");
   17538                                     assert(ios.width() == 0);
   17539                                 }
   17540                                 ios.width(25);
   17541                                 left(ios);
   17542                                 {
   17543                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17544                                     std::string ex(str, iter.base());
   17545                                     assert(ex == "+1_234_567_89_0;*********");
   17546                                     assert(ios.width() == 0);
   17547                                 }
   17548                                 ios.width(25);
   17549                                 right(ios);
   17550                                 {
   17551                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17552                                     std::string ex(str, iter.base());
   17553                                     assert(ex == "*********+1_234_567_89_0;");
   17554                                     assert(ios.width() == 0);
   17555                                 }
   17556                                 ios.width(25);
   17557                                 internal(ios);
   17558                                 {
   17559                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17560                                     std::string ex(str, iter.base());
   17561                                     assert(ex == "+*********1_234_567_89_0;");
   17562                                     assert(ios.width() == 0);
   17563                                 }
   17564                             }
   17565                         }
   17566                     }
   17567                 }
   17568                 uppercase(ios);
   17569                 {
   17570                     noshowpos(ios);
   17571                     {
   17572                         noshowpoint(ios);
   17573                         {
   17574                             ios.imbue(lc);
   17575                             {
   17576                                 ios.width(0);
   17577                                 {
   17578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17579                                     std::string ex(str, iter.base());
   17580                                     assert(ex == "1234567890");
   17581                                     assert(ios.width() == 0);
   17582                                 }
   17583                                 ios.width(25);
   17584                                 left(ios);
   17585                                 {
   17586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17587                                     std::string ex(str, iter.base());
   17588                                     assert(ex == "1234567890***************");
   17589                                     assert(ios.width() == 0);
   17590                                 }
   17591                                 ios.width(25);
   17592                                 right(ios);
   17593                                 {
   17594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17595                                     std::string ex(str, iter.base());
   17596                                     assert(ex == "***************1234567890");
   17597                                     assert(ios.width() == 0);
   17598                                 }
   17599                                 ios.width(25);
   17600                                 internal(ios);
   17601                                 {
   17602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17603                                     std::string ex(str, iter.base());
   17604                                     assert(ex == "***************1234567890");
   17605                                     assert(ios.width() == 0);
   17606                                 }
   17607                             }
   17608                             ios.imbue(lg);
   17609                             {
   17610                                 ios.width(0);
   17611                                 {
   17612                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17613                                     std::string ex(str, iter.base());
   17614                                     assert(ex == "1_234_567_89_0");
   17615                                     assert(ios.width() == 0);
   17616                                 }
   17617                                 ios.width(25);
   17618                                 left(ios);
   17619                                 {
   17620                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17621                                     std::string ex(str, iter.base());
   17622                                     assert(ex == "1_234_567_89_0***********");
   17623                                     assert(ios.width() == 0);
   17624                                 }
   17625                                 ios.width(25);
   17626                                 right(ios);
   17627                                 {
   17628                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17629                                     std::string ex(str, iter.base());
   17630                                     assert(ex == "***********1_234_567_89_0");
   17631                                     assert(ios.width() == 0);
   17632                                 }
   17633                                 ios.width(25);
   17634                                 internal(ios);
   17635                                 {
   17636                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17637                                     std::string ex(str, iter.base());
   17638                                     assert(ex == "***********1_234_567_89_0");
   17639                                     assert(ios.width() == 0);
   17640                                 }
   17641                             }
   17642                         }
   17643                         showpoint(ios);
   17644                         {
   17645                             ios.imbue(lc);
   17646                             {
   17647                                 ios.width(0);
   17648                                 {
   17649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17650                                     std::string ex(str, iter.base());
   17651                                     assert(ex == "1234567890.");
   17652                                     assert(ios.width() == 0);
   17653                                 }
   17654                                 ios.width(25);
   17655                                 left(ios);
   17656                                 {
   17657                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17658                                     std::string ex(str, iter.base());
   17659                                     assert(ex == "1234567890.**************");
   17660                                     assert(ios.width() == 0);
   17661                                 }
   17662                                 ios.width(25);
   17663                                 right(ios);
   17664                                 {
   17665                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17666                                     std::string ex(str, iter.base());
   17667                                     assert(ex == "**************1234567890.");
   17668                                     assert(ios.width() == 0);
   17669                                 }
   17670                                 ios.width(25);
   17671                                 internal(ios);
   17672                                 {
   17673                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17674                                     std::string ex(str, iter.base());
   17675                                     assert(ex == "**************1234567890.");
   17676                                     assert(ios.width() == 0);
   17677                                 }
   17678                             }
   17679                             ios.imbue(lg);
   17680                             {
   17681                                 ios.width(0);
   17682                                 {
   17683                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17684                                     std::string ex(str, iter.base());
   17685                                     assert(ex == "1_234_567_89_0;");
   17686                                     assert(ios.width() == 0);
   17687                                 }
   17688                                 ios.width(25);
   17689                                 left(ios);
   17690                                 {
   17691                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17692                                     std::string ex(str, iter.base());
   17693                                     assert(ex == "1_234_567_89_0;**********");
   17694                                     assert(ios.width() == 0);
   17695                                 }
   17696                                 ios.width(25);
   17697                                 right(ios);
   17698                                 {
   17699                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17700                                     std::string ex(str, iter.base());
   17701                                     assert(ex == "**********1_234_567_89_0;");
   17702                                     assert(ios.width() == 0);
   17703                                 }
   17704                                 ios.width(25);
   17705                                 internal(ios);
   17706                                 {
   17707                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17708                                     std::string ex(str, iter.base());
   17709                                     assert(ex == "**********1_234_567_89_0;");
   17710                                     assert(ios.width() == 0);
   17711                                 }
   17712                             }
   17713                         }
   17714                     }
   17715                     showpos(ios);
   17716                     {
   17717                         noshowpoint(ios);
   17718                         {
   17719                             ios.imbue(lc);
   17720                             {
   17721                                 ios.width(0);
   17722                                 {
   17723                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17724                                     std::string ex(str, iter.base());
   17725                                     assert(ex == "+1234567890");
   17726                                     assert(ios.width() == 0);
   17727                                 }
   17728                                 ios.width(25);
   17729                                 left(ios);
   17730                                 {
   17731                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17732                                     std::string ex(str, iter.base());
   17733                                     assert(ex == "+1234567890**************");
   17734                                     assert(ios.width() == 0);
   17735                                 }
   17736                                 ios.width(25);
   17737                                 right(ios);
   17738                                 {
   17739                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17740                                     std::string ex(str, iter.base());
   17741                                     assert(ex == "**************+1234567890");
   17742                                     assert(ios.width() == 0);
   17743                                 }
   17744                                 ios.width(25);
   17745                                 internal(ios);
   17746                                 {
   17747                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17748                                     std::string ex(str, iter.base());
   17749                                     assert(ex == "+**************1234567890");
   17750                                     assert(ios.width() == 0);
   17751                                 }
   17752                             }
   17753                             ios.imbue(lg);
   17754                             {
   17755                                 ios.width(0);
   17756                                 {
   17757                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17758                                     std::string ex(str, iter.base());
   17759                                     assert(ex == "+1_234_567_89_0");
   17760                                     assert(ios.width() == 0);
   17761                                 }
   17762                                 ios.width(25);
   17763                                 left(ios);
   17764                                 {
   17765                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17766                                     std::string ex(str, iter.base());
   17767                                     assert(ex == "+1_234_567_89_0**********");
   17768                                     assert(ios.width() == 0);
   17769                                 }
   17770                                 ios.width(25);
   17771                                 right(ios);
   17772                                 {
   17773                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17774                                     std::string ex(str, iter.base());
   17775                                     assert(ex == "**********+1_234_567_89_0");
   17776                                     assert(ios.width() == 0);
   17777                                 }
   17778                                 ios.width(25);
   17779                                 internal(ios);
   17780                                 {
   17781                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17782                                     std::string ex(str, iter.base());
   17783                                     assert(ex == "+**********1_234_567_89_0");
   17784                                     assert(ios.width() == 0);
   17785                                 }
   17786                             }
   17787                         }
   17788                         showpoint(ios);
   17789                         {
   17790                             ios.imbue(lc);
   17791                             {
   17792                                 ios.width(0);
   17793                                 {
   17794                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17795                                     std::string ex(str, iter.base());
   17796                                     assert(ex == "+1234567890.");
   17797                                     assert(ios.width() == 0);
   17798                                 }
   17799                                 ios.width(25);
   17800                                 left(ios);
   17801                                 {
   17802                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17803                                     std::string ex(str, iter.base());
   17804                                     assert(ex == "+1234567890.*************");
   17805                                     assert(ios.width() == 0);
   17806                                 }
   17807                                 ios.width(25);
   17808                                 right(ios);
   17809                                 {
   17810                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17811                                     std::string ex(str, iter.base());
   17812                                     assert(ex == "*************+1234567890.");
   17813                                     assert(ios.width() == 0);
   17814                                 }
   17815                                 ios.width(25);
   17816                                 internal(ios);
   17817                                 {
   17818                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17819                                     std::string ex(str, iter.base());
   17820                                     assert(ex == "+*************1234567890.");
   17821                                     assert(ios.width() == 0);
   17822                                 }
   17823                             }
   17824                             ios.imbue(lg);
   17825                             {
   17826                                 ios.width(0);
   17827                                 {
   17828                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17829                                     std::string ex(str, iter.base());
   17830                                     assert(ex == "+1_234_567_89_0;");
   17831                                     assert(ios.width() == 0);
   17832                                 }
   17833                                 ios.width(25);
   17834                                 left(ios);
   17835                                 {
   17836                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17837                                     std::string ex(str, iter.base());
   17838                                     assert(ex == "+1_234_567_89_0;*********");
   17839                                     assert(ios.width() == 0);
   17840                                 }
   17841                                 ios.width(25);
   17842                                 right(ios);
   17843                                 {
   17844                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17845                                     std::string ex(str, iter.base());
   17846                                     assert(ex == "*********+1_234_567_89_0;");
   17847                                     assert(ios.width() == 0);
   17848                                 }
   17849                                 ios.width(25);
   17850                                 internal(ios);
   17851                                 {
   17852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17853                                     std::string ex(str, iter.base());
   17854                                     assert(ex == "+*********1_234_567_89_0;");
   17855                                     assert(ios.width() == 0);
   17856                                 }
   17857                             }
   17858                         }
   17859                     }
   17860                 }
   17861             }
   17862             ios.precision(1);
   17863             {
   17864                 nouppercase(ios);
   17865                 {
   17866                     noshowpos(ios);
   17867                     {
   17868                         noshowpoint(ios);
   17869                         {
   17870                             ios.imbue(lc);
   17871                             {
   17872                                 ios.width(0);
   17873                                 {
   17874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17875                                     std::string ex(str, iter.base());
   17876                                     assert(ex == "1234567890.1");
   17877                                     assert(ios.width() == 0);
   17878                                 }
   17879                                 ios.width(25);
   17880                                 left(ios);
   17881                                 {
   17882                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17883                                     std::string ex(str, iter.base());
   17884                                     assert(ex == "1234567890.1*************");
   17885                                     assert(ios.width() == 0);
   17886                                 }
   17887                                 ios.width(25);
   17888                                 right(ios);
   17889                                 {
   17890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17891                                     std::string ex(str, iter.base());
   17892                                     assert(ex == "*************1234567890.1");
   17893                                     assert(ios.width() == 0);
   17894                                 }
   17895                                 ios.width(25);
   17896                                 internal(ios);
   17897                                 {
   17898                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17899                                     std::string ex(str, iter.base());
   17900                                     assert(ex == "*************1234567890.1");
   17901                                     assert(ios.width() == 0);
   17902                                 }
   17903                             }
   17904                             ios.imbue(lg);
   17905                             {
   17906                                 ios.width(0);
   17907                                 {
   17908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17909                                     std::string ex(str, iter.base());
   17910                                     assert(ex == "1_234_567_89_0;1");
   17911                                     assert(ios.width() == 0);
   17912                                 }
   17913                                 ios.width(25);
   17914                                 left(ios);
   17915                                 {
   17916                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17917                                     std::string ex(str, iter.base());
   17918                                     assert(ex == "1_234_567_89_0;1*********");
   17919                                     assert(ios.width() == 0);
   17920                                 }
   17921                                 ios.width(25);
   17922                                 right(ios);
   17923                                 {
   17924                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17925                                     std::string ex(str, iter.base());
   17926                                     assert(ex == "*********1_234_567_89_0;1");
   17927                                     assert(ios.width() == 0);
   17928                                 }
   17929                                 ios.width(25);
   17930                                 internal(ios);
   17931                                 {
   17932                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17933                                     std::string ex(str, iter.base());
   17934                                     assert(ex == "*********1_234_567_89_0;1");
   17935                                     assert(ios.width() == 0);
   17936                                 }
   17937                             }
   17938                         }
   17939                         showpoint(ios);
   17940                         {
   17941                             ios.imbue(lc);
   17942                             {
   17943                                 ios.width(0);
   17944                                 {
   17945                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17946                                     std::string ex(str, iter.base());
   17947                                     assert(ex == "1234567890.1");
   17948                                     assert(ios.width() == 0);
   17949                                 }
   17950                                 ios.width(25);
   17951                                 left(ios);
   17952                                 {
   17953                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17954                                     std::string ex(str, iter.base());
   17955                                     assert(ex == "1234567890.1*************");
   17956                                     assert(ios.width() == 0);
   17957                                 }
   17958                                 ios.width(25);
   17959                                 right(ios);
   17960                                 {
   17961                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17962                                     std::string ex(str, iter.base());
   17963                                     assert(ex == "*************1234567890.1");
   17964                                     assert(ios.width() == 0);
   17965                                 }
   17966                                 ios.width(25);
   17967                                 internal(ios);
   17968                                 {
   17969                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17970                                     std::string ex(str, iter.base());
   17971                                     assert(ex == "*************1234567890.1");
   17972                                     assert(ios.width() == 0);
   17973                                 }
   17974                             }
   17975                             ios.imbue(lg);
   17976                             {
   17977                                 ios.width(0);
   17978                                 {
   17979                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17980                                     std::string ex(str, iter.base());
   17981                                     assert(ex == "1_234_567_89_0;1");
   17982                                     assert(ios.width() == 0);
   17983                                 }
   17984                                 ios.width(25);
   17985                                 left(ios);
   17986                                 {
   17987                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17988                                     std::string ex(str, iter.base());
   17989                                     assert(ex == "1_234_567_89_0;1*********");
   17990                                     assert(ios.width() == 0);
   17991                                 }
   17992                                 ios.width(25);
   17993                                 right(ios);
   17994                                 {
   17995                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   17996                                     std::string ex(str, iter.base());
   17997                                     assert(ex == "*********1_234_567_89_0;1");
   17998                                     assert(ios.width() == 0);
   17999                                 }
   18000                                 ios.width(25);
   18001                                 internal(ios);
   18002                                 {
   18003                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18004                                     std::string ex(str, iter.base());
   18005                                     assert(ex == "*********1_234_567_89_0;1");
   18006                                     assert(ios.width() == 0);
   18007                                 }
   18008                             }
   18009                         }
   18010                     }
   18011                     showpos(ios);
   18012                     {
   18013                         noshowpoint(ios);
   18014                         {
   18015                             ios.imbue(lc);
   18016                             {
   18017                                 ios.width(0);
   18018                                 {
   18019                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18020                                     std::string ex(str, iter.base());
   18021                                     assert(ex == "+1234567890.1");
   18022                                     assert(ios.width() == 0);
   18023                                 }
   18024                                 ios.width(25);
   18025                                 left(ios);
   18026                                 {
   18027                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18028                                     std::string ex(str, iter.base());
   18029                                     assert(ex == "+1234567890.1************");
   18030                                     assert(ios.width() == 0);
   18031                                 }
   18032                                 ios.width(25);
   18033                                 right(ios);
   18034                                 {
   18035                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18036                                     std::string ex(str, iter.base());
   18037                                     assert(ex == "************+1234567890.1");
   18038                                     assert(ios.width() == 0);
   18039                                 }
   18040                                 ios.width(25);
   18041                                 internal(ios);
   18042                                 {
   18043                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18044                                     std::string ex(str, iter.base());
   18045                                     assert(ex == "+************1234567890.1");
   18046                                     assert(ios.width() == 0);
   18047                                 }
   18048                             }
   18049                             ios.imbue(lg);
   18050                             {
   18051                                 ios.width(0);
   18052                                 {
   18053                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18054                                     std::string ex(str, iter.base());
   18055                                     assert(ex == "+1_234_567_89_0;1");
   18056                                     assert(ios.width() == 0);
   18057                                 }
   18058                                 ios.width(25);
   18059                                 left(ios);
   18060                                 {
   18061                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18062                                     std::string ex(str, iter.base());
   18063                                     assert(ex == "+1_234_567_89_0;1********");
   18064                                     assert(ios.width() == 0);
   18065                                 }
   18066                                 ios.width(25);
   18067                                 right(ios);
   18068                                 {
   18069                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18070                                     std::string ex(str, iter.base());
   18071                                     assert(ex == "********+1_234_567_89_0;1");
   18072                                     assert(ios.width() == 0);
   18073                                 }
   18074                                 ios.width(25);
   18075                                 internal(ios);
   18076                                 {
   18077                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18078                                     std::string ex(str, iter.base());
   18079                                     assert(ex == "+********1_234_567_89_0;1");
   18080                                     assert(ios.width() == 0);
   18081                                 }
   18082                             }
   18083                         }
   18084                         showpoint(ios);
   18085                         {
   18086                             ios.imbue(lc);
   18087                             {
   18088                                 ios.width(0);
   18089                                 {
   18090                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18091                                     std::string ex(str, iter.base());
   18092                                     assert(ex == "+1234567890.1");
   18093                                     assert(ios.width() == 0);
   18094                                 }
   18095                                 ios.width(25);
   18096                                 left(ios);
   18097                                 {
   18098                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18099                                     std::string ex(str, iter.base());
   18100                                     assert(ex == "+1234567890.1************");
   18101                                     assert(ios.width() == 0);
   18102                                 }
   18103                                 ios.width(25);
   18104                                 right(ios);
   18105                                 {
   18106                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18107                                     std::string ex(str, iter.base());
   18108                                     assert(ex == "************+1234567890.1");
   18109                                     assert(ios.width() == 0);
   18110                                 }
   18111                                 ios.width(25);
   18112                                 internal(ios);
   18113                                 {
   18114                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18115                                     std::string ex(str, iter.base());
   18116                                     assert(ex == "+************1234567890.1");
   18117                                     assert(ios.width() == 0);
   18118                                 }
   18119                             }
   18120                             ios.imbue(lg);
   18121                             {
   18122                                 ios.width(0);
   18123                                 {
   18124                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18125                                     std::string ex(str, iter.base());
   18126                                     assert(ex == "+1_234_567_89_0;1");
   18127                                     assert(ios.width() == 0);
   18128                                 }
   18129                                 ios.width(25);
   18130                                 left(ios);
   18131                                 {
   18132                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18133                                     std::string ex(str, iter.base());
   18134                                     assert(ex == "+1_234_567_89_0;1********");
   18135                                     assert(ios.width() == 0);
   18136                                 }
   18137                                 ios.width(25);
   18138                                 right(ios);
   18139                                 {
   18140                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18141                                     std::string ex(str, iter.base());
   18142                                     assert(ex == "********+1_234_567_89_0;1");
   18143                                     assert(ios.width() == 0);
   18144                                 }
   18145                                 ios.width(25);
   18146                                 internal(ios);
   18147                                 {
   18148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18149                                     std::string ex(str, iter.base());
   18150                                     assert(ex == "+********1_234_567_89_0;1");
   18151                                     assert(ios.width() == 0);
   18152                                 }
   18153                             }
   18154                         }
   18155                     }
   18156                 }
   18157                 uppercase(ios);
   18158                 {
   18159                     noshowpos(ios);
   18160                     {
   18161                         noshowpoint(ios);
   18162                         {
   18163                             ios.imbue(lc);
   18164                             {
   18165                                 ios.width(0);
   18166                                 {
   18167                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18168                                     std::string ex(str, iter.base());
   18169                                     assert(ex == "1234567890.1");
   18170                                     assert(ios.width() == 0);
   18171                                 }
   18172                                 ios.width(25);
   18173                                 left(ios);
   18174                                 {
   18175                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18176                                     std::string ex(str, iter.base());
   18177                                     assert(ex == "1234567890.1*************");
   18178                                     assert(ios.width() == 0);
   18179                                 }
   18180                                 ios.width(25);
   18181                                 right(ios);
   18182                                 {
   18183                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18184                                     std::string ex(str, iter.base());
   18185                                     assert(ex == "*************1234567890.1");
   18186                                     assert(ios.width() == 0);
   18187                                 }
   18188                                 ios.width(25);
   18189                                 internal(ios);
   18190                                 {
   18191                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18192                                     std::string ex(str, iter.base());
   18193                                     assert(ex == "*************1234567890.1");
   18194                                     assert(ios.width() == 0);
   18195                                 }
   18196                             }
   18197                             ios.imbue(lg);
   18198                             {
   18199                                 ios.width(0);
   18200                                 {
   18201                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18202                                     std::string ex(str, iter.base());
   18203                                     assert(ex == "1_234_567_89_0;1");
   18204                                     assert(ios.width() == 0);
   18205                                 }
   18206                                 ios.width(25);
   18207                                 left(ios);
   18208                                 {
   18209                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18210                                     std::string ex(str, iter.base());
   18211                                     assert(ex == "1_234_567_89_0;1*********");
   18212                                     assert(ios.width() == 0);
   18213                                 }
   18214                                 ios.width(25);
   18215                                 right(ios);
   18216                                 {
   18217                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18218                                     std::string ex(str, iter.base());
   18219                                     assert(ex == "*********1_234_567_89_0;1");
   18220                                     assert(ios.width() == 0);
   18221                                 }
   18222                                 ios.width(25);
   18223                                 internal(ios);
   18224                                 {
   18225                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18226                                     std::string ex(str, iter.base());
   18227                                     assert(ex == "*********1_234_567_89_0;1");
   18228                                     assert(ios.width() == 0);
   18229                                 }
   18230                             }
   18231                         }
   18232                         showpoint(ios);
   18233                         {
   18234                             ios.imbue(lc);
   18235                             {
   18236                                 ios.width(0);
   18237                                 {
   18238                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18239                                     std::string ex(str, iter.base());
   18240                                     assert(ex == "1234567890.1");
   18241                                     assert(ios.width() == 0);
   18242                                 }
   18243                                 ios.width(25);
   18244                                 left(ios);
   18245                                 {
   18246                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18247                                     std::string ex(str, iter.base());
   18248                                     assert(ex == "1234567890.1*************");
   18249                                     assert(ios.width() == 0);
   18250                                 }
   18251                                 ios.width(25);
   18252                                 right(ios);
   18253                                 {
   18254                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18255                                     std::string ex(str, iter.base());
   18256                                     assert(ex == "*************1234567890.1");
   18257                                     assert(ios.width() == 0);
   18258                                 }
   18259                                 ios.width(25);
   18260                                 internal(ios);
   18261                                 {
   18262                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18263                                     std::string ex(str, iter.base());
   18264                                     assert(ex == "*************1234567890.1");
   18265                                     assert(ios.width() == 0);
   18266                                 }
   18267                             }
   18268                             ios.imbue(lg);
   18269                             {
   18270                                 ios.width(0);
   18271                                 {
   18272                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18273                                     std::string ex(str, iter.base());
   18274                                     assert(ex == "1_234_567_89_0;1");
   18275                                     assert(ios.width() == 0);
   18276                                 }
   18277                                 ios.width(25);
   18278                                 left(ios);
   18279                                 {
   18280                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18281                                     std::string ex(str, iter.base());
   18282                                     assert(ex == "1_234_567_89_0;1*********");
   18283                                     assert(ios.width() == 0);
   18284                                 }
   18285                                 ios.width(25);
   18286                                 right(ios);
   18287                                 {
   18288                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18289                                     std::string ex(str, iter.base());
   18290                                     assert(ex == "*********1_234_567_89_0;1");
   18291                                     assert(ios.width() == 0);
   18292                                 }
   18293                                 ios.width(25);
   18294                                 internal(ios);
   18295                                 {
   18296                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18297                                     std::string ex(str, iter.base());
   18298                                     assert(ex == "*********1_234_567_89_0;1");
   18299                                     assert(ios.width() == 0);
   18300                                 }
   18301                             }
   18302                         }
   18303                     }
   18304                     showpos(ios);
   18305                     {
   18306                         noshowpoint(ios);
   18307                         {
   18308                             ios.imbue(lc);
   18309                             {
   18310                                 ios.width(0);
   18311                                 {
   18312                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18313                                     std::string ex(str, iter.base());
   18314                                     assert(ex == "+1234567890.1");
   18315                                     assert(ios.width() == 0);
   18316                                 }
   18317                                 ios.width(25);
   18318                                 left(ios);
   18319                                 {
   18320                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18321                                     std::string ex(str, iter.base());
   18322                                     assert(ex == "+1234567890.1************");
   18323                                     assert(ios.width() == 0);
   18324                                 }
   18325                                 ios.width(25);
   18326                                 right(ios);
   18327                                 {
   18328                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18329                                     std::string ex(str, iter.base());
   18330                                     assert(ex == "************+1234567890.1");
   18331                                     assert(ios.width() == 0);
   18332                                 }
   18333                                 ios.width(25);
   18334                                 internal(ios);
   18335                                 {
   18336                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18337                                     std::string ex(str, iter.base());
   18338                                     assert(ex == "+************1234567890.1");
   18339                                     assert(ios.width() == 0);
   18340                                 }
   18341                             }
   18342                             ios.imbue(lg);
   18343                             {
   18344                                 ios.width(0);
   18345                                 {
   18346                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18347                                     std::string ex(str, iter.base());
   18348                                     assert(ex == "+1_234_567_89_0;1");
   18349                                     assert(ios.width() == 0);
   18350                                 }
   18351                                 ios.width(25);
   18352                                 left(ios);
   18353                                 {
   18354                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18355                                     std::string ex(str, iter.base());
   18356                                     assert(ex == "+1_234_567_89_0;1********");
   18357                                     assert(ios.width() == 0);
   18358                                 }
   18359                                 ios.width(25);
   18360                                 right(ios);
   18361                                 {
   18362                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18363                                     std::string ex(str, iter.base());
   18364                                     assert(ex == "********+1_234_567_89_0;1");
   18365                                     assert(ios.width() == 0);
   18366                                 }
   18367                                 ios.width(25);
   18368                                 internal(ios);
   18369                                 {
   18370                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18371                                     std::string ex(str, iter.base());
   18372                                     assert(ex == "+********1_234_567_89_0;1");
   18373                                     assert(ios.width() == 0);
   18374                                 }
   18375                             }
   18376                         }
   18377                         showpoint(ios);
   18378                         {
   18379                             ios.imbue(lc);
   18380                             {
   18381                                 ios.width(0);
   18382                                 {
   18383                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18384                                     std::string ex(str, iter.base());
   18385                                     assert(ex == "+1234567890.1");
   18386                                     assert(ios.width() == 0);
   18387                                 }
   18388                                 ios.width(25);
   18389                                 left(ios);
   18390                                 {
   18391                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18392                                     std::string ex(str, iter.base());
   18393                                     assert(ex == "+1234567890.1************");
   18394                                     assert(ios.width() == 0);
   18395                                 }
   18396                                 ios.width(25);
   18397                                 right(ios);
   18398                                 {
   18399                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18400                                     std::string ex(str, iter.base());
   18401                                     assert(ex == "************+1234567890.1");
   18402                                     assert(ios.width() == 0);
   18403                                 }
   18404                                 ios.width(25);
   18405                                 internal(ios);
   18406                                 {
   18407                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18408                                     std::string ex(str, iter.base());
   18409                                     assert(ex == "+************1234567890.1");
   18410                                     assert(ios.width() == 0);
   18411                                 }
   18412                             }
   18413                             ios.imbue(lg);
   18414                             {
   18415                                 ios.width(0);
   18416                                 {
   18417                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18418                                     std::string ex(str, iter.base());
   18419                                     assert(ex == "+1_234_567_89_0;1");
   18420                                     assert(ios.width() == 0);
   18421                                 }
   18422                                 ios.width(25);
   18423                                 left(ios);
   18424                                 {
   18425                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18426                                     std::string ex(str, iter.base());
   18427                                     assert(ex == "+1_234_567_89_0;1********");
   18428                                     assert(ios.width() == 0);
   18429                                 }
   18430                                 ios.width(25);
   18431                                 right(ios);
   18432                                 {
   18433                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18434                                     std::string ex(str, iter.base());
   18435                                     assert(ex == "********+1_234_567_89_0;1");
   18436                                     assert(ios.width() == 0);
   18437                                 }
   18438                                 ios.width(25);
   18439                                 internal(ios);
   18440                                 {
   18441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18442                                     std::string ex(str, iter.base());
   18443                                     assert(ex == "+********1_234_567_89_0;1");
   18444                                     assert(ios.width() == 0);
   18445                                 }
   18446                             }
   18447                         }
   18448                     }
   18449                 }
   18450             }
   18451             ios.precision(6);
   18452             {
   18453                 nouppercase(ios);
   18454                 {
   18455                     noshowpos(ios);
   18456                     {
   18457                         noshowpoint(ios);
   18458                         {
   18459                             ios.imbue(lc);
   18460                             {
   18461                                 ios.width(0);
   18462                                 {
   18463                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18464                                     std::string ex(str, iter.base());
   18465                                     assert(ex == "1234567890.125000");
   18466                                     assert(ios.width() == 0);
   18467                                 }
   18468                                 ios.width(25);
   18469                                 left(ios);
   18470                                 {
   18471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18472                                     std::string ex(str, iter.base());
   18473                                     assert(ex == "1234567890.125000********");
   18474                                     assert(ios.width() == 0);
   18475                                 }
   18476                                 ios.width(25);
   18477                                 right(ios);
   18478                                 {
   18479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18480                                     std::string ex(str, iter.base());
   18481                                     assert(ex == "********1234567890.125000");
   18482                                     assert(ios.width() == 0);
   18483                                 }
   18484                                 ios.width(25);
   18485                                 internal(ios);
   18486                                 {
   18487                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18488                                     std::string ex(str, iter.base());
   18489                                     assert(ex == "********1234567890.125000");
   18490                                     assert(ios.width() == 0);
   18491                                 }
   18492                             }
   18493                             ios.imbue(lg);
   18494                             {
   18495                                 ios.width(0);
   18496                                 {
   18497                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18498                                     std::string ex(str, iter.base());
   18499                                     assert(ex == "1_234_567_89_0;125000");
   18500                                     assert(ios.width() == 0);
   18501                                 }
   18502                                 ios.width(25);
   18503                                 left(ios);
   18504                                 {
   18505                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18506                                     std::string ex(str, iter.base());
   18507                                     assert(ex == "1_234_567_89_0;125000****");
   18508                                     assert(ios.width() == 0);
   18509                                 }
   18510                                 ios.width(25);
   18511                                 right(ios);
   18512                                 {
   18513                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18514                                     std::string ex(str, iter.base());
   18515                                     assert(ex == "****1_234_567_89_0;125000");
   18516                                     assert(ios.width() == 0);
   18517                                 }
   18518                                 ios.width(25);
   18519                                 internal(ios);
   18520                                 {
   18521                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18522                                     std::string ex(str, iter.base());
   18523                                     assert(ex == "****1_234_567_89_0;125000");
   18524                                     assert(ios.width() == 0);
   18525                                 }
   18526                             }
   18527                         }
   18528                         showpoint(ios);
   18529                         {
   18530                             ios.imbue(lc);
   18531                             {
   18532                                 ios.width(0);
   18533                                 {
   18534                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18535                                     std::string ex(str, iter.base());
   18536                                     assert(ex == "1234567890.125000");
   18537                                     assert(ios.width() == 0);
   18538                                 }
   18539                                 ios.width(25);
   18540                                 left(ios);
   18541                                 {
   18542                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18543                                     std::string ex(str, iter.base());
   18544                                     assert(ex == "1234567890.125000********");
   18545                                     assert(ios.width() == 0);
   18546                                 }
   18547                                 ios.width(25);
   18548                                 right(ios);
   18549                                 {
   18550                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18551                                     std::string ex(str, iter.base());
   18552                                     assert(ex == "********1234567890.125000");
   18553                                     assert(ios.width() == 0);
   18554                                 }
   18555                                 ios.width(25);
   18556                                 internal(ios);
   18557                                 {
   18558                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18559                                     std::string ex(str, iter.base());
   18560                                     assert(ex == "********1234567890.125000");
   18561                                     assert(ios.width() == 0);
   18562                                 }
   18563                             }
   18564                             ios.imbue(lg);
   18565                             {
   18566                                 ios.width(0);
   18567                                 {
   18568                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18569                                     std::string ex(str, iter.base());
   18570                                     assert(ex == "1_234_567_89_0;125000");
   18571                                     assert(ios.width() == 0);
   18572                                 }
   18573                                 ios.width(25);
   18574                                 left(ios);
   18575                                 {
   18576                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18577                                     std::string ex(str, iter.base());
   18578                                     assert(ex == "1_234_567_89_0;125000****");
   18579                                     assert(ios.width() == 0);
   18580                                 }
   18581                                 ios.width(25);
   18582                                 right(ios);
   18583                                 {
   18584                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18585                                     std::string ex(str, iter.base());
   18586                                     assert(ex == "****1_234_567_89_0;125000");
   18587                                     assert(ios.width() == 0);
   18588                                 }
   18589                                 ios.width(25);
   18590                                 internal(ios);
   18591                                 {
   18592                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18593                                     std::string ex(str, iter.base());
   18594                                     assert(ex == "****1_234_567_89_0;125000");
   18595                                     assert(ios.width() == 0);
   18596                                 }
   18597                             }
   18598                         }
   18599                     }
   18600                     showpos(ios);
   18601                     {
   18602                         noshowpoint(ios);
   18603                         {
   18604                             ios.imbue(lc);
   18605                             {
   18606                                 ios.width(0);
   18607                                 {
   18608                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18609                                     std::string ex(str, iter.base());
   18610                                     assert(ex == "+1234567890.125000");
   18611                                     assert(ios.width() == 0);
   18612                                 }
   18613                                 ios.width(25);
   18614                                 left(ios);
   18615                                 {
   18616                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18617                                     std::string ex(str, iter.base());
   18618                                     assert(ex == "+1234567890.125000*******");
   18619                                     assert(ios.width() == 0);
   18620                                 }
   18621                                 ios.width(25);
   18622                                 right(ios);
   18623                                 {
   18624                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18625                                     std::string ex(str, iter.base());
   18626                                     assert(ex == "*******+1234567890.125000");
   18627                                     assert(ios.width() == 0);
   18628                                 }
   18629                                 ios.width(25);
   18630                                 internal(ios);
   18631                                 {
   18632                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18633                                     std::string ex(str, iter.base());
   18634                                     assert(ex == "+*******1234567890.125000");
   18635                                     assert(ios.width() == 0);
   18636                                 }
   18637                             }
   18638                             ios.imbue(lg);
   18639                             {
   18640                                 ios.width(0);
   18641                                 {
   18642                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18643                                     std::string ex(str, iter.base());
   18644                                     assert(ex == "+1_234_567_89_0;125000");
   18645                                     assert(ios.width() == 0);
   18646                                 }
   18647                                 ios.width(25);
   18648                                 left(ios);
   18649                                 {
   18650                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18651                                     std::string ex(str, iter.base());
   18652                                     assert(ex == "+1_234_567_89_0;125000***");
   18653                                     assert(ios.width() == 0);
   18654                                 }
   18655                                 ios.width(25);
   18656                                 right(ios);
   18657                                 {
   18658                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18659                                     std::string ex(str, iter.base());
   18660                                     assert(ex == "***+1_234_567_89_0;125000");
   18661                                     assert(ios.width() == 0);
   18662                                 }
   18663                                 ios.width(25);
   18664                                 internal(ios);
   18665                                 {
   18666                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18667                                     std::string ex(str, iter.base());
   18668                                     assert(ex == "+***1_234_567_89_0;125000");
   18669                                     assert(ios.width() == 0);
   18670                                 }
   18671                             }
   18672                         }
   18673                         showpoint(ios);
   18674                         {
   18675                             ios.imbue(lc);
   18676                             {
   18677                                 ios.width(0);
   18678                                 {
   18679                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18680                                     std::string ex(str, iter.base());
   18681                                     assert(ex == "+1234567890.125000");
   18682                                     assert(ios.width() == 0);
   18683                                 }
   18684                                 ios.width(25);
   18685                                 left(ios);
   18686                                 {
   18687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18688                                     std::string ex(str, iter.base());
   18689                                     assert(ex == "+1234567890.125000*******");
   18690                                     assert(ios.width() == 0);
   18691                                 }
   18692                                 ios.width(25);
   18693                                 right(ios);
   18694                                 {
   18695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18696                                     std::string ex(str, iter.base());
   18697                                     assert(ex == "*******+1234567890.125000");
   18698                                     assert(ios.width() == 0);
   18699                                 }
   18700                                 ios.width(25);
   18701                                 internal(ios);
   18702                                 {
   18703                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18704                                     std::string ex(str, iter.base());
   18705                                     assert(ex == "+*******1234567890.125000");
   18706                                     assert(ios.width() == 0);
   18707                                 }
   18708                             }
   18709                             ios.imbue(lg);
   18710                             {
   18711                                 ios.width(0);
   18712                                 {
   18713                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18714                                     std::string ex(str, iter.base());
   18715                                     assert(ex == "+1_234_567_89_0;125000");
   18716                                     assert(ios.width() == 0);
   18717                                 }
   18718                                 ios.width(25);
   18719                                 left(ios);
   18720                                 {
   18721                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18722                                     std::string ex(str, iter.base());
   18723                                     assert(ex == "+1_234_567_89_0;125000***");
   18724                                     assert(ios.width() == 0);
   18725                                 }
   18726                                 ios.width(25);
   18727                                 right(ios);
   18728                                 {
   18729                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18730                                     std::string ex(str, iter.base());
   18731                                     assert(ex == "***+1_234_567_89_0;125000");
   18732                                     assert(ios.width() == 0);
   18733                                 }
   18734                                 ios.width(25);
   18735                                 internal(ios);
   18736                                 {
   18737                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18738                                     std::string ex(str, iter.base());
   18739                                     assert(ex == "+***1_234_567_89_0;125000");
   18740                                     assert(ios.width() == 0);
   18741                                 }
   18742                             }
   18743                         }
   18744                     }
   18745                 }
   18746                 uppercase(ios);
   18747                 {
   18748                     noshowpos(ios);
   18749                     {
   18750                         noshowpoint(ios);
   18751                         {
   18752                             ios.imbue(lc);
   18753                             {
   18754                                 ios.width(0);
   18755                                 {
   18756                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18757                                     std::string ex(str, iter.base());
   18758                                     assert(ex == "1234567890.125000");
   18759                                     assert(ios.width() == 0);
   18760                                 }
   18761                                 ios.width(25);
   18762                                 left(ios);
   18763                                 {
   18764                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18765                                     std::string ex(str, iter.base());
   18766                                     assert(ex == "1234567890.125000********");
   18767                                     assert(ios.width() == 0);
   18768                                 }
   18769                                 ios.width(25);
   18770                                 right(ios);
   18771                                 {
   18772                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18773                                     std::string ex(str, iter.base());
   18774                                     assert(ex == "********1234567890.125000");
   18775                                     assert(ios.width() == 0);
   18776                                 }
   18777                                 ios.width(25);
   18778                                 internal(ios);
   18779                                 {
   18780                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18781                                     std::string ex(str, iter.base());
   18782                                     assert(ex == "********1234567890.125000");
   18783                                     assert(ios.width() == 0);
   18784                                 }
   18785                             }
   18786                             ios.imbue(lg);
   18787                             {
   18788                                 ios.width(0);
   18789                                 {
   18790                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18791                                     std::string ex(str, iter.base());
   18792                                     assert(ex == "1_234_567_89_0;125000");
   18793                                     assert(ios.width() == 0);
   18794                                 }
   18795                                 ios.width(25);
   18796                                 left(ios);
   18797                                 {
   18798                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18799                                     std::string ex(str, iter.base());
   18800                                     assert(ex == "1_234_567_89_0;125000****");
   18801                                     assert(ios.width() == 0);
   18802                                 }
   18803                                 ios.width(25);
   18804                                 right(ios);
   18805                                 {
   18806                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18807                                     std::string ex(str, iter.base());
   18808                                     assert(ex == "****1_234_567_89_0;125000");
   18809                                     assert(ios.width() == 0);
   18810                                 }
   18811                                 ios.width(25);
   18812                                 internal(ios);
   18813                                 {
   18814                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18815                                     std::string ex(str, iter.base());
   18816                                     assert(ex == "****1_234_567_89_0;125000");
   18817                                     assert(ios.width() == 0);
   18818                                 }
   18819                             }
   18820                         }
   18821                         showpoint(ios);
   18822                         {
   18823                             ios.imbue(lc);
   18824                             {
   18825                                 ios.width(0);
   18826                                 {
   18827                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18828                                     std::string ex(str, iter.base());
   18829                                     assert(ex == "1234567890.125000");
   18830                                     assert(ios.width() == 0);
   18831                                 }
   18832                                 ios.width(25);
   18833                                 left(ios);
   18834                                 {
   18835                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18836                                     std::string ex(str, iter.base());
   18837                                     assert(ex == "1234567890.125000********");
   18838                                     assert(ios.width() == 0);
   18839                                 }
   18840                                 ios.width(25);
   18841                                 right(ios);
   18842                                 {
   18843                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18844                                     std::string ex(str, iter.base());
   18845                                     assert(ex == "********1234567890.125000");
   18846                                     assert(ios.width() == 0);
   18847                                 }
   18848                                 ios.width(25);
   18849                                 internal(ios);
   18850                                 {
   18851                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18852                                     std::string ex(str, iter.base());
   18853                                     assert(ex == "********1234567890.125000");
   18854                                     assert(ios.width() == 0);
   18855                                 }
   18856                             }
   18857                             ios.imbue(lg);
   18858                             {
   18859                                 ios.width(0);
   18860                                 {
   18861                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18862                                     std::string ex(str, iter.base());
   18863                                     assert(ex == "1_234_567_89_0;125000");
   18864                                     assert(ios.width() == 0);
   18865                                 }
   18866                                 ios.width(25);
   18867                                 left(ios);
   18868                                 {
   18869                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18870                                     std::string ex(str, iter.base());
   18871                                     assert(ex == "1_234_567_89_0;125000****");
   18872                                     assert(ios.width() == 0);
   18873                                 }
   18874                                 ios.width(25);
   18875                                 right(ios);
   18876                                 {
   18877                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18878                                     std::string ex(str, iter.base());
   18879                                     assert(ex == "****1_234_567_89_0;125000");
   18880                                     assert(ios.width() == 0);
   18881                                 }
   18882                                 ios.width(25);
   18883                                 internal(ios);
   18884                                 {
   18885                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18886                                     std::string ex(str, iter.base());
   18887                                     assert(ex == "****1_234_567_89_0;125000");
   18888                                     assert(ios.width() == 0);
   18889                                 }
   18890                             }
   18891                         }
   18892                     }
   18893                     showpos(ios);
   18894                     {
   18895                         noshowpoint(ios);
   18896                         {
   18897                             ios.imbue(lc);
   18898                             {
   18899                                 ios.width(0);
   18900                                 {
   18901                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18902                                     std::string ex(str, iter.base());
   18903                                     assert(ex == "+1234567890.125000");
   18904                                     assert(ios.width() == 0);
   18905                                 }
   18906                                 ios.width(25);
   18907                                 left(ios);
   18908                                 {
   18909                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18910                                     std::string ex(str, iter.base());
   18911                                     assert(ex == "+1234567890.125000*******");
   18912                                     assert(ios.width() == 0);
   18913                                 }
   18914                                 ios.width(25);
   18915                                 right(ios);
   18916                                 {
   18917                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18918                                     std::string ex(str, iter.base());
   18919                                     assert(ex == "*******+1234567890.125000");
   18920                                     assert(ios.width() == 0);
   18921                                 }
   18922                                 ios.width(25);
   18923                                 internal(ios);
   18924                                 {
   18925                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18926                                     std::string ex(str, iter.base());
   18927                                     assert(ex == "+*******1234567890.125000");
   18928                                     assert(ios.width() == 0);
   18929                                 }
   18930                             }
   18931                             ios.imbue(lg);
   18932                             {
   18933                                 ios.width(0);
   18934                                 {
   18935                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18936                                     std::string ex(str, iter.base());
   18937                                     assert(ex == "+1_234_567_89_0;125000");
   18938                                     assert(ios.width() == 0);
   18939                                 }
   18940                                 ios.width(25);
   18941                                 left(ios);
   18942                                 {
   18943                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18944                                     std::string ex(str, iter.base());
   18945                                     assert(ex == "+1_234_567_89_0;125000***");
   18946                                     assert(ios.width() == 0);
   18947                                 }
   18948                                 ios.width(25);
   18949                                 right(ios);
   18950                                 {
   18951                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18952                                     std::string ex(str, iter.base());
   18953                                     assert(ex == "***+1_234_567_89_0;125000");
   18954                                     assert(ios.width() == 0);
   18955                                 }
   18956                                 ios.width(25);
   18957                                 internal(ios);
   18958                                 {
   18959                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18960                                     std::string ex(str, iter.base());
   18961                                     assert(ex == "+***1_234_567_89_0;125000");
   18962                                     assert(ios.width() == 0);
   18963                                 }
   18964                             }
   18965                         }
   18966                         showpoint(ios);
   18967                         {
   18968                             ios.imbue(lc);
   18969                             {
   18970                                 ios.width(0);
   18971                                 {
   18972                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18973                                     std::string ex(str, iter.base());
   18974                                     assert(ex == "+1234567890.125000");
   18975                                     assert(ios.width() == 0);
   18976                                 }
   18977                                 ios.width(25);
   18978                                 left(ios);
   18979                                 {
   18980                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18981                                     std::string ex(str, iter.base());
   18982                                     assert(ex == "+1234567890.125000*******");
   18983                                     assert(ios.width() == 0);
   18984                                 }
   18985                                 ios.width(25);
   18986                                 right(ios);
   18987                                 {
   18988                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18989                                     std::string ex(str, iter.base());
   18990                                     assert(ex == "*******+1234567890.125000");
   18991                                     assert(ios.width() == 0);
   18992                                 }
   18993                                 ios.width(25);
   18994                                 internal(ios);
   18995                                 {
   18996                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   18997                                     std::string ex(str, iter.base());
   18998                                     assert(ex == "+*******1234567890.125000");
   18999                                     assert(ios.width() == 0);
   19000                                 }
   19001                             }
   19002                             ios.imbue(lg);
   19003                             {
   19004                                 ios.width(0);
   19005                                 {
   19006                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19007                                     std::string ex(str, iter.base());
   19008                                     assert(ex == "+1_234_567_89_0;125000");
   19009                                     assert(ios.width() == 0);
   19010                                 }
   19011                                 ios.width(25);
   19012                                 left(ios);
   19013                                 {
   19014                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19015                                     std::string ex(str, iter.base());
   19016                                     assert(ex == "+1_234_567_89_0;125000***");
   19017                                     assert(ios.width() == 0);
   19018                                 }
   19019                                 ios.width(25);
   19020                                 right(ios);
   19021                                 {
   19022                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19023                                     std::string ex(str, iter.base());
   19024                                     assert(ex == "***+1_234_567_89_0;125000");
   19025                                     assert(ios.width() == 0);
   19026                                 }
   19027                                 ios.width(25);
   19028                                 internal(ios);
   19029                                 {
   19030                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19031                                     std::string ex(str, iter.base());
   19032                                     assert(ex == "+***1_234_567_89_0;125000");
   19033                                     assert(ios.width() == 0);
   19034                                 }
   19035                             }
   19036                         }
   19037                     }
   19038                 }
   19039             }
   19040             ios.precision(16);
   19041             {}
   19042             ios.precision(60);
   19043             {}
   19044         }
   19045     }
   19046 }
   19047 
   19048 void test9()
   19049 {
   19050     char str[200];
   19051     output_iterator<char*> iter;
   19052     std::locale lc = std::locale::classic();
   19053     std::locale lg(lc, new my_numpunct);
   19054     const my_facet f(1);
   19055     {
   19056         long double v = -0.;
   19057         std::ios ios(0);
   19058         scientific(ios);
   19059         // %e
   19060         {
   19061             ios.precision(0);
   19062             {
   19063                 nouppercase(ios);
   19064                 {
   19065                     noshowpos(ios);
   19066                     {
   19067                         noshowpoint(ios);
   19068                         {
   19069                             ios.imbue(lc);
   19070                             {
   19071                                 ios.width(0);
   19072                                 {
   19073                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19074                                     std::string ex(str, iter.base());
   19075                                     assert(ex == "-0e+00");
   19076                                     assert(ios.width() == 0);
   19077                                 }
   19078                                 ios.width(25);
   19079                                 left(ios);
   19080                                 {
   19081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19082                                     std::string ex(str, iter.base());
   19083                                     assert(ex == "-0e+00*******************");
   19084                                     assert(ios.width() == 0);
   19085                                 }
   19086                                 ios.width(25);
   19087                                 right(ios);
   19088                                 {
   19089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19090                                     std::string ex(str, iter.base());
   19091                                     assert(ex == "*******************-0e+00");
   19092                                     assert(ios.width() == 0);
   19093                                 }
   19094                                 ios.width(25);
   19095                                 internal(ios);
   19096                                 {
   19097                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19098                                     std::string ex(str, iter.base());
   19099                                     assert(ex == "-*******************0e+00");
   19100                                     assert(ios.width() == 0);
   19101                                 }
   19102                             }
   19103                             ios.imbue(lg);
   19104                             {
   19105                                 ios.width(0);
   19106                                 {
   19107                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19108                                     std::string ex(str, iter.base());
   19109                                     assert(ex == "-0e+00");
   19110                                     assert(ios.width() == 0);
   19111                                 }
   19112                                 ios.width(25);
   19113                                 left(ios);
   19114                                 {
   19115                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19116                                     std::string ex(str, iter.base());
   19117                                     assert(ex == "-0e+00*******************");
   19118                                     assert(ios.width() == 0);
   19119                                 }
   19120                                 ios.width(25);
   19121                                 right(ios);
   19122                                 {
   19123                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19124                                     std::string ex(str, iter.base());
   19125                                     assert(ex == "*******************-0e+00");
   19126                                     assert(ios.width() == 0);
   19127                                 }
   19128                                 ios.width(25);
   19129                                 internal(ios);
   19130                                 {
   19131                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19132                                     std::string ex(str, iter.base());
   19133                                     assert(ex == "-*******************0e+00");
   19134                                     assert(ios.width() == 0);
   19135                                 }
   19136                             }
   19137                         }
   19138                         showpoint(ios);
   19139                         {
   19140                             ios.imbue(lc);
   19141                             {
   19142                                 ios.width(0);
   19143                                 {
   19144                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19145                                     std::string ex(str, iter.base());
   19146                                     assert(ex == "-0.e+00");
   19147                                     assert(ios.width() == 0);
   19148                                 }
   19149                                 ios.width(25);
   19150                                 left(ios);
   19151                                 {
   19152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19153                                     std::string ex(str, iter.base());
   19154                                     assert(ex == "-0.e+00******************");
   19155                                     assert(ios.width() == 0);
   19156                                 }
   19157                                 ios.width(25);
   19158                                 right(ios);
   19159                                 {
   19160                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19161                                     std::string ex(str, iter.base());
   19162                                     assert(ex == "******************-0.e+00");
   19163                                     assert(ios.width() == 0);
   19164                                 }
   19165                                 ios.width(25);
   19166                                 internal(ios);
   19167                                 {
   19168                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19169                                     std::string ex(str, iter.base());
   19170                                     assert(ex == "-******************0.e+00");
   19171                                     assert(ios.width() == 0);
   19172                                 }
   19173                             }
   19174                             ios.imbue(lg);
   19175                             {
   19176                                 ios.width(0);
   19177                                 {
   19178                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19179                                     std::string ex(str, iter.base());
   19180                                     assert(ex == "-0;e+00");
   19181                                     assert(ios.width() == 0);
   19182                                 }
   19183                                 ios.width(25);
   19184                                 left(ios);
   19185                                 {
   19186                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19187                                     std::string ex(str, iter.base());
   19188                                     assert(ex == "-0;e+00******************");
   19189                                     assert(ios.width() == 0);
   19190                                 }
   19191                                 ios.width(25);
   19192                                 right(ios);
   19193                                 {
   19194                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19195                                     std::string ex(str, iter.base());
   19196                                     assert(ex == "******************-0;e+00");
   19197                                     assert(ios.width() == 0);
   19198                                 }
   19199                                 ios.width(25);
   19200                                 internal(ios);
   19201                                 {
   19202                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19203                                     std::string ex(str, iter.base());
   19204                                     assert(ex == "-******************0;e+00");
   19205                                     assert(ios.width() == 0);
   19206                                 }
   19207                             }
   19208                         }
   19209                     }
   19210                     showpos(ios);
   19211                     {
   19212                         noshowpoint(ios);
   19213                         {
   19214                             ios.imbue(lc);
   19215                             {
   19216                                 ios.width(0);
   19217                                 {
   19218                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19219                                     std::string ex(str, iter.base());
   19220                                     assert(ex == "-0e+00");
   19221                                     assert(ios.width() == 0);
   19222                                 }
   19223                                 ios.width(25);
   19224                                 left(ios);
   19225                                 {
   19226                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19227                                     std::string ex(str, iter.base());
   19228                                     assert(ex == "-0e+00*******************");
   19229                                     assert(ios.width() == 0);
   19230                                 }
   19231                                 ios.width(25);
   19232                                 right(ios);
   19233                                 {
   19234                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19235                                     std::string ex(str, iter.base());
   19236                                     assert(ex == "*******************-0e+00");
   19237                                     assert(ios.width() == 0);
   19238                                 }
   19239                                 ios.width(25);
   19240                                 internal(ios);
   19241                                 {
   19242                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19243                                     std::string ex(str, iter.base());
   19244                                     assert(ex == "-*******************0e+00");
   19245                                     assert(ios.width() == 0);
   19246                                 }
   19247                             }
   19248                             ios.imbue(lg);
   19249                             {
   19250                                 ios.width(0);
   19251                                 {
   19252                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19253                                     std::string ex(str, iter.base());
   19254                                     assert(ex == "-0e+00");
   19255                                     assert(ios.width() == 0);
   19256                                 }
   19257                                 ios.width(25);
   19258                                 left(ios);
   19259                                 {
   19260                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19261                                     std::string ex(str, iter.base());
   19262                                     assert(ex == "-0e+00*******************");
   19263                                     assert(ios.width() == 0);
   19264                                 }
   19265                                 ios.width(25);
   19266                                 right(ios);
   19267                                 {
   19268                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19269                                     std::string ex(str, iter.base());
   19270                                     assert(ex == "*******************-0e+00");
   19271                                     assert(ios.width() == 0);
   19272                                 }
   19273                                 ios.width(25);
   19274                                 internal(ios);
   19275                                 {
   19276                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19277                                     std::string ex(str, iter.base());
   19278                                     assert(ex == "-*******************0e+00");
   19279                                     assert(ios.width() == 0);
   19280                                 }
   19281                             }
   19282                         }
   19283                         showpoint(ios);
   19284                         {
   19285                             ios.imbue(lc);
   19286                             {
   19287                                 ios.width(0);
   19288                                 {
   19289                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19290                                     std::string ex(str, iter.base());
   19291                                     assert(ex == "-0.e+00");
   19292                                     assert(ios.width() == 0);
   19293                                 }
   19294                                 ios.width(25);
   19295                                 left(ios);
   19296                                 {
   19297                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19298                                     std::string ex(str, iter.base());
   19299                                     assert(ex == "-0.e+00******************");
   19300                                     assert(ios.width() == 0);
   19301                                 }
   19302                                 ios.width(25);
   19303                                 right(ios);
   19304                                 {
   19305                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19306                                     std::string ex(str, iter.base());
   19307                                     assert(ex == "******************-0.e+00");
   19308                                     assert(ios.width() == 0);
   19309                                 }
   19310                                 ios.width(25);
   19311                                 internal(ios);
   19312                                 {
   19313                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19314                                     std::string ex(str, iter.base());
   19315                                     assert(ex == "-******************0.e+00");
   19316                                     assert(ios.width() == 0);
   19317                                 }
   19318                             }
   19319                             ios.imbue(lg);
   19320                             {
   19321                                 ios.width(0);
   19322                                 {
   19323                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19324                                     std::string ex(str, iter.base());
   19325                                     assert(ex == "-0;e+00");
   19326                                     assert(ios.width() == 0);
   19327                                 }
   19328                                 ios.width(25);
   19329                                 left(ios);
   19330                                 {
   19331                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19332                                     std::string ex(str, iter.base());
   19333                                     assert(ex == "-0;e+00******************");
   19334                                     assert(ios.width() == 0);
   19335                                 }
   19336                                 ios.width(25);
   19337                                 right(ios);
   19338                                 {
   19339                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19340                                     std::string ex(str, iter.base());
   19341                                     assert(ex == "******************-0;e+00");
   19342                                     assert(ios.width() == 0);
   19343                                 }
   19344                                 ios.width(25);
   19345                                 internal(ios);
   19346                                 {
   19347                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19348                                     std::string ex(str, iter.base());
   19349                                     assert(ex == "-******************0;e+00");
   19350                                     assert(ios.width() == 0);
   19351                                 }
   19352                             }
   19353                         }
   19354                     }
   19355                 }
   19356                 uppercase(ios);
   19357                 {
   19358                     noshowpos(ios);
   19359                     {
   19360                         noshowpoint(ios);
   19361                         {
   19362                             ios.imbue(lc);
   19363                             {
   19364                                 ios.width(0);
   19365                                 {
   19366                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19367                                     std::string ex(str, iter.base());
   19368                                     assert(ex == "-0E+00");
   19369                                     assert(ios.width() == 0);
   19370                                 }
   19371                                 ios.width(25);
   19372                                 left(ios);
   19373                                 {
   19374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19375                                     std::string ex(str, iter.base());
   19376                                     assert(ex == "-0E+00*******************");
   19377                                     assert(ios.width() == 0);
   19378                                 }
   19379                                 ios.width(25);
   19380                                 right(ios);
   19381                                 {
   19382                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19383                                     std::string ex(str, iter.base());
   19384                                     assert(ex == "*******************-0E+00");
   19385                                     assert(ios.width() == 0);
   19386                                 }
   19387                                 ios.width(25);
   19388                                 internal(ios);
   19389                                 {
   19390                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19391                                     std::string ex(str, iter.base());
   19392                                     assert(ex == "-*******************0E+00");
   19393                                     assert(ios.width() == 0);
   19394                                 }
   19395                             }
   19396                             ios.imbue(lg);
   19397                             {
   19398                                 ios.width(0);
   19399                                 {
   19400                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19401                                     std::string ex(str, iter.base());
   19402                                     assert(ex == "-0E+00");
   19403                                     assert(ios.width() == 0);
   19404                                 }
   19405                                 ios.width(25);
   19406                                 left(ios);
   19407                                 {
   19408                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19409                                     std::string ex(str, iter.base());
   19410                                     assert(ex == "-0E+00*******************");
   19411                                     assert(ios.width() == 0);
   19412                                 }
   19413                                 ios.width(25);
   19414                                 right(ios);
   19415                                 {
   19416                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19417                                     std::string ex(str, iter.base());
   19418                                     assert(ex == "*******************-0E+00");
   19419                                     assert(ios.width() == 0);
   19420                                 }
   19421                                 ios.width(25);
   19422                                 internal(ios);
   19423                                 {
   19424                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19425                                     std::string ex(str, iter.base());
   19426                                     assert(ex == "-*******************0E+00");
   19427                                     assert(ios.width() == 0);
   19428                                 }
   19429                             }
   19430                         }
   19431                         showpoint(ios);
   19432                         {
   19433                             ios.imbue(lc);
   19434                             {
   19435                                 ios.width(0);
   19436                                 {
   19437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19438                                     std::string ex(str, iter.base());
   19439                                     assert(ex == "-0.E+00");
   19440                                     assert(ios.width() == 0);
   19441                                 }
   19442                                 ios.width(25);
   19443                                 left(ios);
   19444                                 {
   19445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19446                                     std::string ex(str, iter.base());
   19447                                     assert(ex == "-0.E+00******************");
   19448                                     assert(ios.width() == 0);
   19449                                 }
   19450                                 ios.width(25);
   19451                                 right(ios);
   19452                                 {
   19453                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19454                                     std::string ex(str, iter.base());
   19455                                     assert(ex == "******************-0.E+00");
   19456                                     assert(ios.width() == 0);
   19457                                 }
   19458                                 ios.width(25);
   19459                                 internal(ios);
   19460                                 {
   19461                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19462                                     std::string ex(str, iter.base());
   19463                                     assert(ex == "-******************0.E+00");
   19464                                     assert(ios.width() == 0);
   19465                                 }
   19466                             }
   19467                             ios.imbue(lg);
   19468                             {
   19469                                 ios.width(0);
   19470                                 {
   19471                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19472                                     std::string ex(str, iter.base());
   19473                                     assert(ex == "-0;E+00");
   19474                                     assert(ios.width() == 0);
   19475                                 }
   19476                                 ios.width(25);
   19477                                 left(ios);
   19478                                 {
   19479                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19480                                     std::string ex(str, iter.base());
   19481                                     assert(ex == "-0;E+00******************");
   19482                                     assert(ios.width() == 0);
   19483                                 }
   19484                                 ios.width(25);
   19485                                 right(ios);
   19486                                 {
   19487                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19488                                     std::string ex(str, iter.base());
   19489                                     assert(ex == "******************-0;E+00");
   19490                                     assert(ios.width() == 0);
   19491                                 }
   19492                                 ios.width(25);
   19493                                 internal(ios);
   19494                                 {
   19495                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19496                                     std::string ex(str, iter.base());
   19497                                     assert(ex == "-******************0;E+00");
   19498                                     assert(ios.width() == 0);
   19499                                 }
   19500                             }
   19501                         }
   19502                     }
   19503                     showpos(ios);
   19504                     {
   19505                         noshowpoint(ios);
   19506                         {
   19507                             ios.imbue(lc);
   19508                             {
   19509                                 ios.width(0);
   19510                                 {
   19511                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19512                                     std::string ex(str, iter.base());
   19513                                     assert(ex == "-0E+00");
   19514                                     assert(ios.width() == 0);
   19515                                 }
   19516                                 ios.width(25);
   19517                                 left(ios);
   19518                                 {
   19519                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19520                                     std::string ex(str, iter.base());
   19521                                     assert(ex == "-0E+00*******************");
   19522                                     assert(ios.width() == 0);
   19523                                 }
   19524                                 ios.width(25);
   19525                                 right(ios);
   19526                                 {
   19527                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19528                                     std::string ex(str, iter.base());
   19529                                     assert(ex == "*******************-0E+00");
   19530                                     assert(ios.width() == 0);
   19531                                 }
   19532                                 ios.width(25);
   19533                                 internal(ios);
   19534                                 {
   19535                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19536                                     std::string ex(str, iter.base());
   19537                                     assert(ex == "-*******************0E+00");
   19538                                     assert(ios.width() == 0);
   19539                                 }
   19540                             }
   19541                             ios.imbue(lg);
   19542                             {
   19543                                 ios.width(0);
   19544                                 {
   19545                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19546                                     std::string ex(str, iter.base());
   19547                                     assert(ex == "-0E+00");
   19548                                     assert(ios.width() == 0);
   19549                                 }
   19550                                 ios.width(25);
   19551                                 left(ios);
   19552                                 {
   19553                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19554                                     std::string ex(str, iter.base());
   19555                                     assert(ex == "-0E+00*******************");
   19556                                     assert(ios.width() == 0);
   19557                                 }
   19558                                 ios.width(25);
   19559                                 right(ios);
   19560                                 {
   19561                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19562                                     std::string ex(str, iter.base());
   19563                                     assert(ex == "*******************-0E+00");
   19564                                     assert(ios.width() == 0);
   19565                                 }
   19566                                 ios.width(25);
   19567                                 internal(ios);
   19568                                 {
   19569                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19570                                     std::string ex(str, iter.base());
   19571                                     assert(ex == "-*******************0E+00");
   19572                                     assert(ios.width() == 0);
   19573                                 }
   19574                             }
   19575                         }
   19576                         showpoint(ios);
   19577                         {
   19578                             ios.imbue(lc);
   19579                             {
   19580                                 ios.width(0);
   19581                                 {
   19582                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19583                                     std::string ex(str, iter.base());
   19584                                     assert(ex == "-0.E+00");
   19585                                     assert(ios.width() == 0);
   19586                                 }
   19587                                 ios.width(25);
   19588                                 left(ios);
   19589                                 {
   19590                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19591                                     std::string ex(str, iter.base());
   19592                                     assert(ex == "-0.E+00******************");
   19593                                     assert(ios.width() == 0);
   19594                                 }
   19595                                 ios.width(25);
   19596                                 right(ios);
   19597                                 {
   19598                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19599                                     std::string ex(str, iter.base());
   19600                                     assert(ex == "******************-0.E+00");
   19601                                     assert(ios.width() == 0);
   19602                                 }
   19603                                 ios.width(25);
   19604                                 internal(ios);
   19605                                 {
   19606                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19607                                     std::string ex(str, iter.base());
   19608                                     assert(ex == "-******************0.E+00");
   19609                                     assert(ios.width() == 0);
   19610                                 }
   19611                             }
   19612                             ios.imbue(lg);
   19613                             {
   19614                                 ios.width(0);
   19615                                 {
   19616                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19617                                     std::string ex(str, iter.base());
   19618                                     assert(ex == "-0;E+00");
   19619                                     assert(ios.width() == 0);
   19620                                 }
   19621                                 ios.width(25);
   19622                                 left(ios);
   19623                                 {
   19624                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19625                                     std::string ex(str, iter.base());
   19626                                     assert(ex == "-0;E+00******************");
   19627                                     assert(ios.width() == 0);
   19628                                 }
   19629                                 ios.width(25);
   19630                                 right(ios);
   19631                                 {
   19632                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19633                                     std::string ex(str, iter.base());
   19634                                     assert(ex == "******************-0;E+00");
   19635                                     assert(ios.width() == 0);
   19636                                 }
   19637                                 ios.width(25);
   19638                                 internal(ios);
   19639                                 {
   19640                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19641                                     std::string ex(str, iter.base());
   19642                                     assert(ex == "-******************0;E+00");
   19643                                     assert(ios.width() == 0);
   19644                                 }
   19645                             }
   19646                         }
   19647                     }
   19648                 }
   19649             }
   19650             ios.precision(1);
   19651             {
   19652                 nouppercase(ios);
   19653                 {
   19654                     noshowpos(ios);
   19655                     {
   19656                         noshowpoint(ios);
   19657                         {
   19658                             ios.imbue(lc);
   19659                             {
   19660                                 ios.width(0);
   19661                                 {
   19662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19663                                     std::string ex(str, iter.base());
   19664                                     assert(ex == "-0.0e+00");
   19665                                     assert(ios.width() == 0);
   19666                                 }
   19667                                 ios.width(25);
   19668                                 left(ios);
   19669                                 {
   19670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19671                                     std::string ex(str, iter.base());
   19672                                     assert(ex == "-0.0e+00*****************");
   19673                                     assert(ios.width() == 0);
   19674                                 }
   19675                                 ios.width(25);
   19676                                 right(ios);
   19677                                 {
   19678                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19679                                     std::string ex(str, iter.base());
   19680                                     assert(ex == "*****************-0.0e+00");
   19681                                     assert(ios.width() == 0);
   19682                                 }
   19683                                 ios.width(25);
   19684                                 internal(ios);
   19685                                 {
   19686                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19687                                     std::string ex(str, iter.base());
   19688                                     assert(ex == "-*****************0.0e+00");
   19689                                     assert(ios.width() == 0);
   19690                                 }
   19691                             }
   19692                             ios.imbue(lg);
   19693                             {
   19694                                 ios.width(0);
   19695                                 {
   19696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19697                                     std::string ex(str, iter.base());
   19698                                     assert(ex == "-0;0e+00");
   19699                                     assert(ios.width() == 0);
   19700                                 }
   19701                                 ios.width(25);
   19702                                 left(ios);
   19703                                 {
   19704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19705                                     std::string ex(str, iter.base());
   19706                                     assert(ex == "-0;0e+00*****************");
   19707                                     assert(ios.width() == 0);
   19708                                 }
   19709                                 ios.width(25);
   19710                                 right(ios);
   19711                                 {
   19712                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19713                                     std::string ex(str, iter.base());
   19714                                     assert(ex == "*****************-0;0e+00");
   19715                                     assert(ios.width() == 0);
   19716                                 }
   19717                                 ios.width(25);
   19718                                 internal(ios);
   19719                                 {
   19720                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19721                                     std::string ex(str, iter.base());
   19722                                     assert(ex == "-*****************0;0e+00");
   19723                                     assert(ios.width() == 0);
   19724                                 }
   19725                             }
   19726                         }
   19727                         showpoint(ios);
   19728                         {
   19729                             ios.imbue(lc);
   19730                             {
   19731                                 ios.width(0);
   19732                                 {
   19733                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19734                                     std::string ex(str, iter.base());
   19735                                     assert(ex == "-0.0e+00");
   19736                                     assert(ios.width() == 0);
   19737                                 }
   19738                                 ios.width(25);
   19739                                 left(ios);
   19740                                 {
   19741                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19742                                     std::string ex(str, iter.base());
   19743                                     assert(ex == "-0.0e+00*****************");
   19744                                     assert(ios.width() == 0);
   19745                                 }
   19746                                 ios.width(25);
   19747                                 right(ios);
   19748                                 {
   19749                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19750                                     std::string ex(str, iter.base());
   19751                                     assert(ex == "*****************-0.0e+00");
   19752                                     assert(ios.width() == 0);
   19753                                 }
   19754                                 ios.width(25);
   19755                                 internal(ios);
   19756                                 {
   19757                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19758                                     std::string ex(str, iter.base());
   19759                                     assert(ex == "-*****************0.0e+00");
   19760                                     assert(ios.width() == 0);
   19761                                 }
   19762                             }
   19763                             ios.imbue(lg);
   19764                             {
   19765                                 ios.width(0);
   19766                                 {
   19767                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19768                                     std::string ex(str, iter.base());
   19769                                     assert(ex == "-0;0e+00");
   19770                                     assert(ios.width() == 0);
   19771                                 }
   19772                                 ios.width(25);
   19773                                 left(ios);
   19774                                 {
   19775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19776                                     std::string ex(str, iter.base());
   19777                                     assert(ex == "-0;0e+00*****************");
   19778                                     assert(ios.width() == 0);
   19779                                 }
   19780                                 ios.width(25);
   19781                                 right(ios);
   19782                                 {
   19783                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19784                                     std::string ex(str, iter.base());
   19785                                     assert(ex == "*****************-0;0e+00");
   19786                                     assert(ios.width() == 0);
   19787                                 }
   19788                                 ios.width(25);
   19789                                 internal(ios);
   19790                                 {
   19791                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19792                                     std::string ex(str, iter.base());
   19793                                     assert(ex == "-*****************0;0e+00");
   19794                                     assert(ios.width() == 0);
   19795                                 }
   19796                             }
   19797                         }
   19798                     }
   19799                     showpos(ios);
   19800                     {
   19801                         noshowpoint(ios);
   19802                         {
   19803                             ios.imbue(lc);
   19804                             {
   19805                                 ios.width(0);
   19806                                 {
   19807                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19808                                     std::string ex(str, iter.base());
   19809                                     assert(ex == "-0.0e+00");
   19810                                     assert(ios.width() == 0);
   19811                                 }
   19812                                 ios.width(25);
   19813                                 left(ios);
   19814                                 {
   19815                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19816                                     std::string ex(str, iter.base());
   19817                                     assert(ex == "-0.0e+00*****************");
   19818                                     assert(ios.width() == 0);
   19819                                 }
   19820                                 ios.width(25);
   19821                                 right(ios);
   19822                                 {
   19823                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19824                                     std::string ex(str, iter.base());
   19825                                     assert(ex == "*****************-0.0e+00");
   19826                                     assert(ios.width() == 0);
   19827                                 }
   19828                                 ios.width(25);
   19829                                 internal(ios);
   19830                                 {
   19831                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19832                                     std::string ex(str, iter.base());
   19833                                     assert(ex == "-*****************0.0e+00");
   19834                                     assert(ios.width() == 0);
   19835                                 }
   19836                             }
   19837                             ios.imbue(lg);
   19838                             {
   19839                                 ios.width(0);
   19840                                 {
   19841                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19842                                     std::string ex(str, iter.base());
   19843                                     assert(ex == "-0;0e+00");
   19844                                     assert(ios.width() == 0);
   19845                                 }
   19846                                 ios.width(25);
   19847                                 left(ios);
   19848                                 {
   19849                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19850                                     std::string ex(str, iter.base());
   19851                                     assert(ex == "-0;0e+00*****************");
   19852                                     assert(ios.width() == 0);
   19853                                 }
   19854                                 ios.width(25);
   19855                                 right(ios);
   19856                                 {
   19857                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19858                                     std::string ex(str, iter.base());
   19859                                     assert(ex == "*****************-0;0e+00");
   19860                                     assert(ios.width() == 0);
   19861                                 }
   19862                                 ios.width(25);
   19863                                 internal(ios);
   19864                                 {
   19865                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19866                                     std::string ex(str, iter.base());
   19867                                     assert(ex == "-*****************0;0e+00");
   19868                                     assert(ios.width() == 0);
   19869                                 }
   19870                             }
   19871                         }
   19872                         showpoint(ios);
   19873                         {
   19874                             ios.imbue(lc);
   19875                             {
   19876                                 ios.width(0);
   19877                                 {
   19878                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19879                                     std::string ex(str, iter.base());
   19880                                     assert(ex == "-0.0e+00");
   19881                                     assert(ios.width() == 0);
   19882                                 }
   19883                                 ios.width(25);
   19884                                 left(ios);
   19885                                 {
   19886                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19887                                     std::string ex(str, iter.base());
   19888                                     assert(ex == "-0.0e+00*****************");
   19889                                     assert(ios.width() == 0);
   19890                                 }
   19891                                 ios.width(25);
   19892                                 right(ios);
   19893                                 {
   19894                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19895                                     std::string ex(str, iter.base());
   19896                                     assert(ex == "*****************-0.0e+00");
   19897                                     assert(ios.width() == 0);
   19898                                 }
   19899                                 ios.width(25);
   19900                                 internal(ios);
   19901                                 {
   19902                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19903                                     std::string ex(str, iter.base());
   19904                                     assert(ex == "-*****************0.0e+00");
   19905                                     assert(ios.width() == 0);
   19906                                 }
   19907                             }
   19908                             ios.imbue(lg);
   19909                             {
   19910                                 ios.width(0);
   19911                                 {
   19912                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19913                                     std::string ex(str, iter.base());
   19914                                     assert(ex == "-0;0e+00");
   19915                                     assert(ios.width() == 0);
   19916                                 }
   19917                                 ios.width(25);
   19918                                 left(ios);
   19919                                 {
   19920                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19921                                     std::string ex(str, iter.base());
   19922                                     assert(ex == "-0;0e+00*****************");
   19923                                     assert(ios.width() == 0);
   19924                                 }
   19925                                 ios.width(25);
   19926                                 right(ios);
   19927                                 {
   19928                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19929                                     std::string ex(str, iter.base());
   19930                                     assert(ex == "*****************-0;0e+00");
   19931                                     assert(ios.width() == 0);
   19932                                 }
   19933                                 ios.width(25);
   19934                                 internal(ios);
   19935                                 {
   19936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19937                                     std::string ex(str, iter.base());
   19938                                     assert(ex == "-*****************0;0e+00");
   19939                                     assert(ios.width() == 0);
   19940                                 }
   19941                             }
   19942                         }
   19943                     }
   19944                 }
   19945                 uppercase(ios);
   19946                 {
   19947                     noshowpos(ios);
   19948                     {
   19949                         noshowpoint(ios);
   19950                         {
   19951                             ios.imbue(lc);
   19952                             {
   19953                                 ios.width(0);
   19954                                 {
   19955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19956                                     std::string ex(str, iter.base());
   19957                                     assert(ex == "-0.0E+00");
   19958                                     assert(ios.width() == 0);
   19959                                 }
   19960                                 ios.width(25);
   19961                                 left(ios);
   19962                                 {
   19963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19964                                     std::string ex(str, iter.base());
   19965                                     assert(ex == "-0.0E+00*****************");
   19966                                     assert(ios.width() == 0);
   19967                                 }
   19968                                 ios.width(25);
   19969                                 right(ios);
   19970                                 {
   19971                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19972                                     std::string ex(str, iter.base());
   19973                                     assert(ex == "*****************-0.0E+00");
   19974                                     assert(ios.width() == 0);
   19975                                 }
   19976                                 ios.width(25);
   19977                                 internal(ios);
   19978                                 {
   19979                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19980                                     std::string ex(str, iter.base());
   19981                                     assert(ex == "-*****************0.0E+00");
   19982                                     assert(ios.width() == 0);
   19983                                 }
   19984                             }
   19985                             ios.imbue(lg);
   19986                             {
   19987                                 ios.width(0);
   19988                                 {
   19989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19990                                     std::string ex(str, iter.base());
   19991                                     assert(ex == "-0;0E+00");
   19992                                     assert(ios.width() == 0);
   19993                                 }
   19994                                 ios.width(25);
   19995                                 left(ios);
   19996                                 {
   19997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   19998                                     std::string ex(str, iter.base());
   19999                                     assert(ex == "-0;0E+00*****************");
   20000                                     assert(ios.width() == 0);
   20001                                 }
   20002                                 ios.width(25);
   20003                                 right(ios);
   20004                                 {
   20005                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20006                                     std::string ex(str, iter.base());
   20007                                     assert(ex == "*****************-0;0E+00");
   20008                                     assert(ios.width() == 0);
   20009                                 }
   20010                                 ios.width(25);
   20011                                 internal(ios);
   20012                                 {
   20013                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20014                                     std::string ex(str, iter.base());
   20015                                     assert(ex == "-*****************0;0E+00");
   20016                                     assert(ios.width() == 0);
   20017                                 }
   20018                             }
   20019                         }
   20020                         showpoint(ios);
   20021                         {
   20022                             ios.imbue(lc);
   20023                             {
   20024                                 ios.width(0);
   20025                                 {
   20026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20027                                     std::string ex(str, iter.base());
   20028                                     assert(ex == "-0.0E+00");
   20029                                     assert(ios.width() == 0);
   20030                                 }
   20031                                 ios.width(25);
   20032                                 left(ios);
   20033                                 {
   20034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20035                                     std::string ex(str, iter.base());
   20036                                     assert(ex == "-0.0E+00*****************");
   20037                                     assert(ios.width() == 0);
   20038                                 }
   20039                                 ios.width(25);
   20040                                 right(ios);
   20041                                 {
   20042                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20043                                     std::string ex(str, iter.base());
   20044                                     assert(ex == "*****************-0.0E+00");
   20045                                     assert(ios.width() == 0);
   20046                                 }
   20047                                 ios.width(25);
   20048                                 internal(ios);
   20049                                 {
   20050                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20051                                     std::string ex(str, iter.base());
   20052                                     assert(ex == "-*****************0.0E+00");
   20053                                     assert(ios.width() == 0);
   20054                                 }
   20055                             }
   20056                             ios.imbue(lg);
   20057                             {
   20058                                 ios.width(0);
   20059                                 {
   20060                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20061                                     std::string ex(str, iter.base());
   20062                                     assert(ex == "-0;0E+00");
   20063                                     assert(ios.width() == 0);
   20064                                 }
   20065                                 ios.width(25);
   20066                                 left(ios);
   20067                                 {
   20068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20069                                     std::string ex(str, iter.base());
   20070                                     assert(ex == "-0;0E+00*****************");
   20071                                     assert(ios.width() == 0);
   20072                                 }
   20073                                 ios.width(25);
   20074                                 right(ios);
   20075                                 {
   20076                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20077                                     std::string ex(str, iter.base());
   20078                                     assert(ex == "*****************-0;0E+00");
   20079                                     assert(ios.width() == 0);
   20080                                 }
   20081                                 ios.width(25);
   20082                                 internal(ios);
   20083                                 {
   20084                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20085                                     std::string ex(str, iter.base());
   20086                                     assert(ex == "-*****************0;0E+00");
   20087                                     assert(ios.width() == 0);
   20088                                 }
   20089                             }
   20090                         }
   20091                     }
   20092                     showpos(ios);
   20093                     {
   20094                         noshowpoint(ios);
   20095                         {
   20096                             ios.imbue(lc);
   20097                             {
   20098                                 ios.width(0);
   20099                                 {
   20100                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20101                                     std::string ex(str, iter.base());
   20102                                     assert(ex == "-0.0E+00");
   20103                                     assert(ios.width() == 0);
   20104                                 }
   20105                                 ios.width(25);
   20106                                 left(ios);
   20107                                 {
   20108                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20109                                     std::string ex(str, iter.base());
   20110                                     assert(ex == "-0.0E+00*****************");
   20111                                     assert(ios.width() == 0);
   20112                                 }
   20113                                 ios.width(25);
   20114                                 right(ios);
   20115                                 {
   20116                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20117                                     std::string ex(str, iter.base());
   20118                                     assert(ex == "*****************-0.0E+00");
   20119                                     assert(ios.width() == 0);
   20120                                 }
   20121                                 ios.width(25);
   20122                                 internal(ios);
   20123                                 {
   20124                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20125                                     std::string ex(str, iter.base());
   20126                                     assert(ex == "-*****************0.0E+00");
   20127                                     assert(ios.width() == 0);
   20128                                 }
   20129                             }
   20130                             ios.imbue(lg);
   20131                             {
   20132                                 ios.width(0);
   20133                                 {
   20134                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20135                                     std::string ex(str, iter.base());
   20136                                     assert(ex == "-0;0E+00");
   20137                                     assert(ios.width() == 0);
   20138                                 }
   20139                                 ios.width(25);
   20140                                 left(ios);
   20141                                 {
   20142                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20143                                     std::string ex(str, iter.base());
   20144                                     assert(ex == "-0;0E+00*****************");
   20145                                     assert(ios.width() == 0);
   20146                                 }
   20147                                 ios.width(25);
   20148                                 right(ios);
   20149                                 {
   20150                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20151                                     std::string ex(str, iter.base());
   20152                                     assert(ex == "*****************-0;0E+00");
   20153                                     assert(ios.width() == 0);
   20154                                 }
   20155                                 ios.width(25);
   20156                                 internal(ios);
   20157                                 {
   20158                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20159                                     std::string ex(str, iter.base());
   20160                                     assert(ex == "-*****************0;0E+00");
   20161                                     assert(ios.width() == 0);
   20162                                 }
   20163                             }
   20164                         }
   20165                         showpoint(ios);
   20166                         {
   20167                             ios.imbue(lc);
   20168                             {
   20169                                 ios.width(0);
   20170                                 {
   20171                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20172                                     std::string ex(str, iter.base());
   20173                                     assert(ex == "-0.0E+00");
   20174                                     assert(ios.width() == 0);
   20175                                 }
   20176                                 ios.width(25);
   20177                                 left(ios);
   20178                                 {
   20179                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20180                                     std::string ex(str, iter.base());
   20181                                     assert(ex == "-0.0E+00*****************");
   20182                                     assert(ios.width() == 0);
   20183                                 }
   20184                                 ios.width(25);
   20185                                 right(ios);
   20186                                 {
   20187                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20188                                     std::string ex(str, iter.base());
   20189                                     assert(ex == "*****************-0.0E+00");
   20190                                     assert(ios.width() == 0);
   20191                                 }
   20192                                 ios.width(25);
   20193                                 internal(ios);
   20194                                 {
   20195                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20196                                     std::string ex(str, iter.base());
   20197                                     assert(ex == "-*****************0.0E+00");
   20198                                     assert(ios.width() == 0);
   20199                                 }
   20200                             }
   20201                             ios.imbue(lg);
   20202                             {
   20203                                 ios.width(0);
   20204                                 {
   20205                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20206                                     std::string ex(str, iter.base());
   20207                                     assert(ex == "-0;0E+00");
   20208                                     assert(ios.width() == 0);
   20209                                 }
   20210                                 ios.width(25);
   20211                                 left(ios);
   20212                                 {
   20213                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20214                                     std::string ex(str, iter.base());
   20215                                     assert(ex == "-0;0E+00*****************");
   20216                                     assert(ios.width() == 0);
   20217                                 }
   20218                                 ios.width(25);
   20219                                 right(ios);
   20220                                 {
   20221                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20222                                     std::string ex(str, iter.base());
   20223                                     assert(ex == "*****************-0;0E+00");
   20224                                     assert(ios.width() == 0);
   20225                                 }
   20226                                 ios.width(25);
   20227                                 internal(ios);
   20228                                 {
   20229                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20230                                     std::string ex(str, iter.base());
   20231                                     assert(ex == "-*****************0;0E+00");
   20232                                     assert(ios.width() == 0);
   20233                                 }
   20234                             }
   20235                         }
   20236                     }
   20237                 }
   20238             }
   20239             ios.precision(6);
   20240             {
   20241                 nouppercase(ios);
   20242                 {
   20243                     noshowpos(ios);
   20244                     {
   20245                         noshowpoint(ios);
   20246                         {
   20247                             ios.imbue(lc);
   20248                             {
   20249                                 ios.width(0);
   20250                                 {
   20251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20252                                     std::string ex(str, iter.base());
   20253                                     assert(ex == "-0.000000e+00");
   20254                                     assert(ios.width() == 0);
   20255                                 }
   20256                                 ios.width(25);
   20257                                 left(ios);
   20258                                 {
   20259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20260                                     std::string ex(str, iter.base());
   20261                                     assert(ex == "-0.000000e+00************");
   20262                                     assert(ios.width() == 0);
   20263                                 }
   20264                                 ios.width(25);
   20265                                 right(ios);
   20266                                 {
   20267                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20268                                     std::string ex(str, iter.base());
   20269                                     assert(ex == "************-0.000000e+00");
   20270                                     assert(ios.width() == 0);
   20271                                 }
   20272                                 ios.width(25);
   20273                                 internal(ios);
   20274                                 {
   20275                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20276                                     std::string ex(str, iter.base());
   20277                                     assert(ex == "-************0.000000e+00");
   20278                                     assert(ios.width() == 0);
   20279                                 }
   20280                             }
   20281                             ios.imbue(lg);
   20282                             {
   20283                                 ios.width(0);
   20284                                 {
   20285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20286                                     std::string ex(str, iter.base());
   20287                                     assert(ex == "-0;000000e+00");
   20288                                     assert(ios.width() == 0);
   20289                                 }
   20290                                 ios.width(25);
   20291                                 left(ios);
   20292                                 {
   20293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20294                                     std::string ex(str, iter.base());
   20295                                     assert(ex == "-0;000000e+00************");
   20296                                     assert(ios.width() == 0);
   20297                                 }
   20298                                 ios.width(25);
   20299                                 right(ios);
   20300                                 {
   20301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20302                                     std::string ex(str, iter.base());
   20303                                     assert(ex == "************-0;000000e+00");
   20304                                     assert(ios.width() == 0);
   20305                                 }
   20306                                 ios.width(25);
   20307                                 internal(ios);
   20308                                 {
   20309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20310                                     std::string ex(str, iter.base());
   20311                                     assert(ex == "-************0;000000e+00");
   20312                                     assert(ios.width() == 0);
   20313                                 }
   20314                             }
   20315                         }
   20316                         showpoint(ios);
   20317                         {
   20318                             ios.imbue(lc);
   20319                             {
   20320                                 ios.width(0);
   20321                                 {
   20322                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20323                                     std::string ex(str, iter.base());
   20324                                     assert(ex == "-0.000000e+00");
   20325                                     assert(ios.width() == 0);
   20326                                 }
   20327                                 ios.width(25);
   20328                                 left(ios);
   20329                                 {
   20330                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20331                                     std::string ex(str, iter.base());
   20332                                     assert(ex == "-0.000000e+00************");
   20333                                     assert(ios.width() == 0);
   20334                                 }
   20335                                 ios.width(25);
   20336                                 right(ios);
   20337                                 {
   20338                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20339                                     std::string ex(str, iter.base());
   20340                                     assert(ex == "************-0.000000e+00");
   20341                                     assert(ios.width() == 0);
   20342                                 }
   20343                                 ios.width(25);
   20344                                 internal(ios);
   20345                                 {
   20346                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20347                                     std::string ex(str, iter.base());
   20348                                     assert(ex == "-************0.000000e+00");
   20349                                     assert(ios.width() == 0);
   20350                                 }
   20351                             }
   20352                             ios.imbue(lg);
   20353                             {
   20354                                 ios.width(0);
   20355                                 {
   20356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20357                                     std::string ex(str, iter.base());
   20358                                     assert(ex == "-0;000000e+00");
   20359                                     assert(ios.width() == 0);
   20360                                 }
   20361                                 ios.width(25);
   20362                                 left(ios);
   20363                                 {
   20364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20365                                     std::string ex(str, iter.base());
   20366                                     assert(ex == "-0;000000e+00************");
   20367                                     assert(ios.width() == 0);
   20368                                 }
   20369                                 ios.width(25);
   20370                                 right(ios);
   20371                                 {
   20372                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20373                                     std::string ex(str, iter.base());
   20374                                     assert(ex == "************-0;000000e+00");
   20375                                     assert(ios.width() == 0);
   20376                                 }
   20377                                 ios.width(25);
   20378                                 internal(ios);
   20379                                 {
   20380                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20381                                     std::string ex(str, iter.base());
   20382                                     assert(ex == "-************0;000000e+00");
   20383                                     assert(ios.width() == 0);
   20384                                 }
   20385                             }
   20386                         }
   20387                     }
   20388                     showpos(ios);
   20389                     {
   20390                         noshowpoint(ios);
   20391                         {
   20392                             ios.imbue(lc);
   20393                             {
   20394                                 ios.width(0);
   20395                                 {
   20396                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20397                                     std::string ex(str, iter.base());
   20398                                     assert(ex == "-0.000000e+00");
   20399                                     assert(ios.width() == 0);
   20400                                 }
   20401                                 ios.width(25);
   20402                                 left(ios);
   20403                                 {
   20404                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20405                                     std::string ex(str, iter.base());
   20406                                     assert(ex == "-0.000000e+00************");
   20407                                     assert(ios.width() == 0);
   20408                                 }
   20409                                 ios.width(25);
   20410                                 right(ios);
   20411                                 {
   20412                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20413                                     std::string ex(str, iter.base());
   20414                                     assert(ex == "************-0.000000e+00");
   20415                                     assert(ios.width() == 0);
   20416                                 }
   20417                                 ios.width(25);
   20418                                 internal(ios);
   20419                                 {
   20420                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20421                                     std::string ex(str, iter.base());
   20422                                     assert(ex == "-************0.000000e+00");
   20423                                     assert(ios.width() == 0);
   20424                                 }
   20425                             }
   20426                             ios.imbue(lg);
   20427                             {
   20428                                 ios.width(0);
   20429                                 {
   20430                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20431                                     std::string ex(str, iter.base());
   20432                                     assert(ex == "-0;000000e+00");
   20433                                     assert(ios.width() == 0);
   20434                                 }
   20435                                 ios.width(25);
   20436                                 left(ios);
   20437                                 {
   20438                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20439                                     std::string ex(str, iter.base());
   20440                                     assert(ex == "-0;000000e+00************");
   20441                                     assert(ios.width() == 0);
   20442                                 }
   20443                                 ios.width(25);
   20444                                 right(ios);
   20445                                 {
   20446                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20447                                     std::string ex(str, iter.base());
   20448                                     assert(ex == "************-0;000000e+00");
   20449                                     assert(ios.width() == 0);
   20450                                 }
   20451                                 ios.width(25);
   20452                                 internal(ios);
   20453                                 {
   20454                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20455                                     std::string ex(str, iter.base());
   20456                                     assert(ex == "-************0;000000e+00");
   20457                                     assert(ios.width() == 0);
   20458                                 }
   20459                             }
   20460                         }
   20461                         showpoint(ios);
   20462                         {
   20463                             ios.imbue(lc);
   20464                             {
   20465                                 ios.width(0);
   20466                                 {
   20467                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20468                                     std::string ex(str, iter.base());
   20469                                     assert(ex == "-0.000000e+00");
   20470                                     assert(ios.width() == 0);
   20471                                 }
   20472                                 ios.width(25);
   20473                                 left(ios);
   20474                                 {
   20475                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20476                                     std::string ex(str, iter.base());
   20477                                     assert(ex == "-0.000000e+00************");
   20478                                     assert(ios.width() == 0);
   20479                                 }
   20480                                 ios.width(25);
   20481                                 right(ios);
   20482                                 {
   20483                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20484                                     std::string ex(str, iter.base());
   20485                                     assert(ex == "************-0.000000e+00");
   20486                                     assert(ios.width() == 0);
   20487                                 }
   20488                                 ios.width(25);
   20489                                 internal(ios);
   20490                                 {
   20491                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20492                                     std::string ex(str, iter.base());
   20493                                     assert(ex == "-************0.000000e+00");
   20494                                     assert(ios.width() == 0);
   20495                                 }
   20496                             }
   20497                             ios.imbue(lg);
   20498                             {
   20499                                 ios.width(0);
   20500                                 {
   20501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20502                                     std::string ex(str, iter.base());
   20503                                     assert(ex == "-0;000000e+00");
   20504                                     assert(ios.width() == 0);
   20505                                 }
   20506                                 ios.width(25);
   20507                                 left(ios);
   20508                                 {
   20509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20510                                     std::string ex(str, iter.base());
   20511                                     assert(ex == "-0;000000e+00************");
   20512                                     assert(ios.width() == 0);
   20513                                 }
   20514                                 ios.width(25);
   20515                                 right(ios);
   20516                                 {
   20517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20518                                     std::string ex(str, iter.base());
   20519                                     assert(ex == "************-0;000000e+00");
   20520                                     assert(ios.width() == 0);
   20521                                 }
   20522                                 ios.width(25);
   20523                                 internal(ios);
   20524                                 {
   20525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20526                                     std::string ex(str, iter.base());
   20527                                     assert(ex == "-************0;000000e+00");
   20528                                     assert(ios.width() == 0);
   20529                                 }
   20530                             }
   20531                         }
   20532                     }
   20533                 }
   20534                 uppercase(ios);
   20535                 {
   20536                     noshowpos(ios);
   20537                     {
   20538                         noshowpoint(ios);
   20539                         {
   20540                             ios.imbue(lc);
   20541                             {
   20542                                 ios.width(0);
   20543                                 {
   20544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20545                                     std::string ex(str, iter.base());
   20546                                     assert(ex == "-0.000000E+00");
   20547                                     assert(ios.width() == 0);
   20548                                 }
   20549                                 ios.width(25);
   20550                                 left(ios);
   20551                                 {
   20552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20553                                     std::string ex(str, iter.base());
   20554                                     assert(ex == "-0.000000E+00************");
   20555                                     assert(ios.width() == 0);
   20556                                 }
   20557                                 ios.width(25);
   20558                                 right(ios);
   20559                                 {
   20560                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20561                                     std::string ex(str, iter.base());
   20562                                     assert(ex == "************-0.000000E+00");
   20563                                     assert(ios.width() == 0);
   20564                                 }
   20565                                 ios.width(25);
   20566                                 internal(ios);
   20567                                 {
   20568                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20569                                     std::string ex(str, iter.base());
   20570                                     assert(ex == "-************0.000000E+00");
   20571                                     assert(ios.width() == 0);
   20572                                 }
   20573                             }
   20574                             ios.imbue(lg);
   20575                             {
   20576                                 ios.width(0);
   20577                                 {
   20578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20579                                     std::string ex(str, iter.base());
   20580                                     assert(ex == "-0;000000E+00");
   20581                                     assert(ios.width() == 0);
   20582                                 }
   20583                                 ios.width(25);
   20584                                 left(ios);
   20585                                 {
   20586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20587                                     std::string ex(str, iter.base());
   20588                                     assert(ex == "-0;000000E+00************");
   20589                                     assert(ios.width() == 0);
   20590                                 }
   20591                                 ios.width(25);
   20592                                 right(ios);
   20593                                 {
   20594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20595                                     std::string ex(str, iter.base());
   20596                                     assert(ex == "************-0;000000E+00");
   20597                                     assert(ios.width() == 0);
   20598                                 }
   20599                                 ios.width(25);
   20600                                 internal(ios);
   20601                                 {
   20602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20603                                     std::string ex(str, iter.base());
   20604                                     assert(ex == "-************0;000000E+00");
   20605                                     assert(ios.width() == 0);
   20606                                 }
   20607                             }
   20608                         }
   20609                         showpoint(ios);
   20610                         {
   20611                             ios.imbue(lc);
   20612                             {
   20613                                 ios.width(0);
   20614                                 {
   20615                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20616                                     std::string ex(str, iter.base());
   20617                                     assert(ex == "-0.000000E+00");
   20618                                     assert(ios.width() == 0);
   20619                                 }
   20620                                 ios.width(25);
   20621                                 left(ios);
   20622                                 {
   20623                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20624                                     std::string ex(str, iter.base());
   20625                                     assert(ex == "-0.000000E+00************");
   20626                                     assert(ios.width() == 0);
   20627                                 }
   20628                                 ios.width(25);
   20629                                 right(ios);
   20630                                 {
   20631                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20632                                     std::string ex(str, iter.base());
   20633                                     assert(ex == "************-0.000000E+00");
   20634                                     assert(ios.width() == 0);
   20635                                 }
   20636                                 ios.width(25);
   20637                                 internal(ios);
   20638                                 {
   20639                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20640                                     std::string ex(str, iter.base());
   20641                                     assert(ex == "-************0.000000E+00");
   20642                                     assert(ios.width() == 0);
   20643                                 }
   20644                             }
   20645                             ios.imbue(lg);
   20646                             {
   20647                                 ios.width(0);
   20648                                 {
   20649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20650                                     std::string ex(str, iter.base());
   20651                                     assert(ex == "-0;000000E+00");
   20652                                     assert(ios.width() == 0);
   20653                                 }
   20654                                 ios.width(25);
   20655                                 left(ios);
   20656                                 {
   20657                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20658                                     std::string ex(str, iter.base());
   20659                                     assert(ex == "-0;000000E+00************");
   20660                                     assert(ios.width() == 0);
   20661                                 }
   20662                                 ios.width(25);
   20663                                 right(ios);
   20664                                 {
   20665                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20666                                     std::string ex(str, iter.base());
   20667                                     assert(ex == "************-0;000000E+00");
   20668                                     assert(ios.width() == 0);
   20669                                 }
   20670                                 ios.width(25);
   20671                                 internal(ios);
   20672                                 {
   20673                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20674                                     std::string ex(str, iter.base());
   20675                                     assert(ex == "-************0;000000E+00");
   20676                                     assert(ios.width() == 0);
   20677                                 }
   20678                             }
   20679                         }
   20680                     }
   20681                     showpos(ios);
   20682                     {
   20683                         noshowpoint(ios);
   20684                         {
   20685                             ios.imbue(lc);
   20686                             {
   20687                                 ios.width(0);
   20688                                 {
   20689                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20690                                     std::string ex(str, iter.base());
   20691                                     assert(ex == "-0.000000E+00");
   20692                                     assert(ios.width() == 0);
   20693                                 }
   20694                                 ios.width(25);
   20695                                 left(ios);
   20696                                 {
   20697                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20698                                     std::string ex(str, iter.base());
   20699                                     assert(ex == "-0.000000E+00************");
   20700                                     assert(ios.width() == 0);
   20701                                 }
   20702                                 ios.width(25);
   20703                                 right(ios);
   20704                                 {
   20705                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20706                                     std::string ex(str, iter.base());
   20707                                     assert(ex == "************-0.000000E+00");
   20708                                     assert(ios.width() == 0);
   20709                                 }
   20710                                 ios.width(25);
   20711                                 internal(ios);
   20712                                 {
   20713                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20714                                     std::string ex(str, iter.base());
   20715                                     assert(ex == "-************0.000000E+00");
   20716                                     assert(ios.width() == 0);
   20717                                 }
   20718                             }
   20719                             ios.imbue(lg);
   20720                             {
   20721                                 ios.width(0);
   20722                                 {
   20723                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20724                                     std::string ex(str, iter.base());
   20725                                     assert(ex == "-0;000000E+00");
   20726                                     assert(ios.width() == 0);
   20727                                 }
   20728                                 ios.width(25);
   20729                                 left(ios);
   20730                                 {
   20731                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20732                                     std::string ex(str, iter.base());
   20733                                     assert(ex == "-0;000000E+00************");
   20734                                     assert(ios.width() == 0);
   20735                                 }
   20736                                 ios.width(25);
   20737                                 right(ios);
   20738                                 {
   20739                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20740                                     std::string ex(str, iter.base());
   20741                                     assert(ex == "************-0;000000E+00");
   20742                                     assert(ios.width() == 0);
   20743                                 }
   20744                                 ios.width(25);
   20745                                 internal(ios);
   20746                                 {
   20747                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20748                                     std::string ex(str, iter.base());
   20749                                     assert(ex == "-************0;000000E+00");
   20750                                     assert(ios.width() == 0);
   20751                                 }
   20752                             }
   20753                         }
   20754                         showpoint(ios);
   20755                         {
   20756                             ios.imbue(lc);
   20757                             {
   20758                                 ios.width(0);
   20759                                 {
   20760                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20761                                     std::string ex(str, iter.base());
   20762                                     assert(ex == "-0.000000E+00");
   20763                                     assert(ios.width() == 0);
   20764                                 }
   20765                                 ios.width(25);
   20766                                 left(ios);
   20767                                 {
   20768                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20769                                     std::string ex(str, iter.base());
   20770                                     assert(ex == "-0.000000E+00************");
   20771                                     assert(ios.width() == 0);
   20772                                 }
   20773                                 ios.width(25);
   20774                                 right(ios);
   20775                                 {
   20776                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20777                                     std::string ex(str, iter.base());
   20778                                     assert(ex == "************-0.000000E+00");
   20779                                     assert(ios.width() == 0);
   20780                                 }
   20781                                 ios.width(25);
   20782                                 internal(ios);
   20783                                 {
   20784                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20785                                     std::string ex(str, iter.base());
   20786                                     assert(ex == "-************0.000000E+00");
   20787                                     assert(ios.width() == 0);
   20788                                 }
   20789                             }
   20790                             ios.imbue(lg);
   20791                             {
   20792                                 ios.width(0);
   20793                                 {
   20794                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20795                                     std::string ex(str, iter.base());
   20796                                     assert(ex == "-0;000000E+00");
   20797                                     assert(ios.width() == 0);
   20798                                 }
   20799                                 ios.width(25);
   20800                                 left(ios);
   20801                                 {
   20802                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20803                                     std::string ex(str, iter.base());
   20804                                     assert(ex == "-0;000000E+00************");
   20805                                     assert(ios.width() == 0);
   20806                                 }
   20807                                 ios.width(25);
   20808                                 right(ios);
   20809                                 {
   20810                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20811                                     std::string ex(str, iter.base());
   20812                                     assert(ex == "************-0;000000E+00");
   20813                                     assert(ios.width() == 0);
   20814                                 }
   20815                                 ios.width(25);
   20816                                 internal(ios);
   20817                                 {
   20818                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20819                                     std::string ex(str, iter.base());
   20820                                     assert(ex == "-************0;000000E+00");
   20821                                     assert(ios.width() == 0);
   20822                                 }
   20823                             }
   20824                         }
   20825                     }
   20826                 }
   20827             }
   20828             ios.precision(16);
   20829             {
   20830             }
   20831             ios.precision(60);
   20832             {
   20833             }
   20834         }
   20835     }
   20836 }
   20837 
   20838 void test10()
   20839 {
   20840     char str[200];
   20841     output_iterator<char*> iter;
   20842     std::locale lc = std::locale::classic();
   20843     std::locale lg(lc, new my_numpunct);
   20844     const my_facet f(1);
   20845     {
   20846         long double v = 1234567890.125;
   20847         std::ios ios(0);
   20848         scientific(ios);
   20849         // %e
   20850         {
   20851             ios.precision(0);
   20852             {
   20853                 nouppercase(ios);
   20854                 {
   20855                     noshowpos(ios);
   20856                     {
   20857                         noshowpoint(ios);
   20858                         {
   20859                             ios.imbue(lc);
   20860                             {
   20861                                 ios.width(0);
   20862                                 {
   20863                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20864                                     std::string ex(str, iter.base());
   20865                                     assert(ex == "1e+09");
   20866                                     assert(ios.width() == 0);
   20867                                 }
   20868                                 ios.width(25);
   20869                                 left(ios);
   20870                                 {
   20871                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20872                                     std::string ex(str, iter.base());
   20873                                     assert(ex == "1e+09********************");
   20874                                     assert(ios.width() == 0);
   20875                                 }
   20876                                 ios.width(25);
   20877                                 right(ios);
   20878                                 {
   20879                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20880                                     std::string ex(str, iter.base());
   20881                                     assert(ex == "********************1e+09");
   20882                                     assert(ios.width() == 0);
   20883                                 }
   20884                                 ios.width(25);
   20885                                 internal(ios);
   20886                                 {
   20887                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20888                                     std::string ex(str, iter.base());
   20889                                     assert(ex == "********************1e+09");
   20890                                     assert(ios.width() == 0);
   20891                                 }
   20892                             }
   20893                             ios.imbue(lg);
   20894                             {
   20895                                 ios.width(0);
   20896                                 {
   20897                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20898                                     std::string ex(str, iter.base());
   20899                                     assert(ex == "1e+09");
   20900                                     assert(ios.width() == 0);
   20901                                 }
   20902                                 ios.width(25);
   20903                                 left(ios);
   20904                                 {
   20905                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20906                                     std::string ex(str, iter.base());
   20907                                     assert(ex == "1e+09********************");
   20908                                     assert(ios.width() == 0);
   20909                                 }
   20910                                 ios.width(25);
   20911                                 right(ios);
   20912                                 {
   20913                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20914                                     std::string ex(str, iter.base());
   20915                                     assert(ex == "********************1e+09");
   20916                                     assert(ios.width() == 0);
   20917                                 }
   20918                                 ios.width(25);
   20919                                 internal(ios);
   20920                                 {
   20921                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20922                                     std::string ex(str, iter.base());
   20923                                     assert(ex == "********************1e+09");
   20924                                     assert(ios.width() == 0);
   20925                                 }
   20926                             }
   20927                         }
   20928                         showpoint(ios);
   20929                         {
   20930                             ios.imbue(lc);
   20931                             {
   20932                                 ios.width(0);
   20933                                 {
   20934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20935                                     std::string ex(str, iter.base());
   20936                                     assert(ex == "1.e+09");
   20937                                     assert(ios.width() == 0);
   20938                                 }
   20939                                 ios.width(25);
   20940                                 left(ios);
   20941                                 {
   20942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20943                                     std::string ex(str, iter.base());
   20944                                     assert(ex == "1.e+09*******************");
   20945                                     assert(ios.width() == 0);
   20946                                 }
   20947                                 ios.width(25);
   20948                                 right(ios);
   20949                                 {
   20950                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20951                                     std::string ex(str, iter.base());
   20952                                     assert(ex == "*******************1.e+09");
   20953                                     assert(ios.width() == 0);
   20954                                 }
   20955                                 ios.width(25);
   20956                                 internal(ios);
   20957                                 {
   20958                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20959                                     std::string ex(str, iter.base());
   20960                                     assert(ex == "*******************1.e+09");
   20961                                     assert(ios.width() == 0);
   20962                                 }
   20963                             }
   20964                             ios.imbue(lg);
   20965                             {
   20966                                 ios.width(0);
   20967                                 {
   20968                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20969                                     std::string ex(str, iter.base());
   20970                                     assert(ex == "1;e+09");
   20971                                     assert(ios.width() == 0);
   20972                                 }
   20973                                 ios.width(25);
   20974                                 left(ios);
   20975                                 {
   20976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20977                                     std::string ex(str, iter.base());
   20978                                     assert(ex == "1;e+09*******************");
   20979                                     assert(ios.width() == 0);
   20980                                 }
   20981                                 ios.width(25);
   20982                                 right(ios);
   20983                                 {
   20984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20985                                     std::string ex(str, iter.base());
   20986                                     assert(ex == "*******************1;e+09");
   20987                                     assert(ios.width() == 0);
   20988                                 }
   20989                                 ios.width(25);
   20990                                 internal(ios);
   20991                                 {
   20992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   20993                                     std::string ex(str, iter.base());
   20994                                     assert(ex == "*******************1;e+09");
   20995                                     assert(ios.width() == 0);
   20996                                 }
   20997                             }
   20998                         }
   20999                     }
   21000                     showpos(ios);
   21001                     {
   21002                         noshowpoint(ios);
   21003                         {
   21004                             ios.imbue(lc);
   21005                             {
   21006                                 ios.width(0);
   21007                                 {
   21008                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21009                                     std::string ex(str, iter.base());
   21010                                     assert(ex == "+1e+09");
   21011                                     assert(ios.width() == 0);
   21012                                 }
   21013                                 ios.width(25);
   21014                                 left(ios);
   21015                                 {
   21016                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21017                                     std::string ex(str, iter.base());
   21018                                     assert(ex == "+1e+09*******************");
   21019                                     assert(ios.width() == 0);
   21020                                 }
   21021                                 ios.width(25);
   21022                                 right(ios);
   21023                                 {
   21024                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21025                                     std::string ex(str, iter.base());
   21026                                     assert(ex == "*******************+1e+09");
   21027                                     assert(ios.width() == 0);
   21028                                 }
   21029                                 ios.width(25);
   21030                                 internal(ios);
   21031                                 {
   21032                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21033                                     std::string ex(str, iter.base());
   21034                                     assert(ex == "+*******************1e+09");
   21035                                     assert(ios.width() == 0);
   21036                                 }
   21037                             }
   21038                             ios.imbue(lg);
   21039                             {
   21040                                 ios.width(0);
   21041                                 {
   21042                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21043                                     std::string ex(str, iter.base());
   21044                                     assert(ex == "+1e+09");
   21045                                     assert(ios.width() == 0);
   21046                                 }
   21047                                 ios.width(25);
   21048                                 left(ios);
   21049                                 {
   21050                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21051                                     std::string ex(str, iter.base());
   21052                                     assert(ex == "+1e+09*******************");
   21053                                     assert(ios.width() == 0);
   21054                                 }
   21055                                 ios.width(25);
   21056                                 right(ios);
   21057                                 {
   21058                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21059                                     std::string ex(str, iter.base());
   21060                                     assert(ex == "*******************+1e+09");
   21061                                     assert(ios.width() == 0);
   21062                                 }
   21063                                 ios.width(25);
   21064                                 internal(ios);
   21065                                 {
   21066                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21067                                     std::string ex(str, iter.base());
   21068                                     assert(ex == "+*******************1e+09");
   21069                                     assert(ios.width() == 0);
   21070                                 }
   21071                             }
   21072                         }
   21073                         showpoint(ios);
   21074                         {
   21075                             ios.imbue(lc);
   21076                             {
   21077                                 ios.width(0);
   21078                                 {
   21079                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21080                                     std::string ex(str, iter.base());
   21081                                     assert(ex == "+1.e+09");
   21082                                     assert(ios.width() == 0);
   21083                                 }
   21084                                 ios.width(25);
   21085                                 left(ios);
   21086                                 {
   21087                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21088                                     std::string ex(str, iter.base());
   21089                                     assert(ex == "+1.e+09******************");
   21090                                     assert(ios.width() == 0);
   21091                                 }
   21092                                 ios.width(25);
   21093                                 right(ios);
   21094                                 {
   21095                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21096                                     std::string ex(str, iter.base());
   21097                                     assert(ex == "******************+1.e+09");
   21098                                     assert(ios.width() == 0);
   21099                                 }
   21100                                 ios.width(25);
   21101                                 internal(ios);
   21102                                 {
   21103                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21104                                     std::string ex(str, iter.base());
   21105                                     assert(ex == "+******************1.e+09");
   21106                                     assert(ios.width() == 0);
   21107                                 }
   21108                             }
   21109                             ios.imbue(lg);
   21110                             {
   21111                                 ios.width(0);
   21112                                 {
   21113                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21114                                     std::string ex(str, iter.base());
   21115                                     assert(ex == "+1;e+09");
   21116                                     assert(ios.width() == 0);
   21117                                 }
   21118                                 ios.width(25);
   21119                                 left(ios);
   21120                                 {
   21121                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21122                                     std::string ex(str, iter.base());
   21123                                     assert(ex == "+1;e+09******************");
   21124                                     assert(ios.width() == 0);
   21125                                 }
   21126                                 ios.width(25);
   21127                                 right(ios);
   21128                                 {
   21129                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21130                                     std::string ex(str, iter.base());
   21131                                     assert(ex == "******************+1;e+09");
   21132                                     assert(ios.width() == 0);
   21133                                 }
   21134                                 ios.width(25);
   21135                                 internal(ios);
   21136                                 {
   21137                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21138                                     std::string ex(str, iter.base());
   21139                                     assert(ex == "+******************1;e+09");
   21140                                     assert(ios.width() == 0);
   21141                                 }
   21142                             }
   21143                         }
   21144                     }
   21145                 }
   21146                 uppercase(ios);
   21147                 {
   21148                     noshowpos(ios);
   21149                     {
   21150                         noshowpoint(ios);
   21151                         {
   21152                             ios.imbue(lc);
   21153                             {
   21154                                 ios.width(0);
   21155                                 {
   21156                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21157                                     std::string ex(str, iter.base());
   21158                                     assert(ex == "1E+09");
   21159                                     assert(ios.width() == 0);
   21160                                 }
   21161                                 ios.width(25);
   21162                                 left(ios);
   21163                                 {
   21164                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21165                                     std::string ex(str, iter.base());
   21166                                     assert(ex == "1E+09********************");
   21167                                     assert(ios.width() == 0);
   21168                                 }
   21169                                 ios.width(25);
   21170                                 right(ios);
   21171                                 {
   21172                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21173                                     std::string ex(str, iter.base());
   21174                                     assert(ex == "********************1E+09");
   21175                                     assert(ios.width() == 0);
   21176                                 }
   21177                                 ios.width(25);
   21178                                 internal(ios);
   21179                                 {
   21180                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21181                                     std::string ex(str, iter.base());
   21182                                     assert(ex == "********************1E+09");
   21183                                     assert(ios.width() == 0);
   21184                                 }
   21185                             }
   21186                             ios.imbue(lg);
   21187                             {
   21188                                 ios.width(0);
   21189                                 {
   21190                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21191                                     std::string ex(str, iter.base());
   21192                                     assert(ex == "1E+09");
   21193                                     assert(ios.width() == 0);
   21194                                 }
   21195                                 ios.width(25);
   21196                                 left(ios);
   21197                                 {
   21198                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21199                                     std::string ex(str, iter.base());
   21200                                     assert(ex == "1E+09********************");
   21201                                     assert(ios.width() == 0);
   21202                                 }
   21203                                 ios.width(25);
   21204                                 right(ios);
   21205                                 {
   21206                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21207                                     std::string ex(str, iter.base());
   21208                                     assert(ex == "********************1E+09");
   21209                                     assert(ios.width() == 0);
   21210                                 }
   21211                                 ios.width(25);
   21212                                 internal(ios);
   21213                                 {
   21214                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21215                                     std::string ex(str, iter.base());
   21216                                     assert(ex == "********************1E+09");
   21217                                     assert(ios.width() == 0);
   21218                                 }
   21219                             }
   21220                         }
   21221                         showpoint(ios);
   21222                         {
   21223                             ios.imbue(lc);
   21224                             {
   21225                                 ios.width(0);
   21226                                 {
   21227                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21228                                     std::string ex(str, iter.base());
   21229                                     assert(ex == "1.E+09");
   21230                                     assert(ios.width() == 0);
   21231                                 }
   21232                                 ios.width(25);
   21233                                 left(ios);
   21234                                 {
   21235                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21236                                     std::string ex(str, iter.base());
   21237                                     assert(ex == "1.E+09*******************");
   21238                                     assert(ios.width() == 0);
   21239                                 }
   21240                                 ios.width(25);
   21241                                 right(ios);
   21242                                 {
   21243                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21244                                     std::string ex(str, iter.base());
   21245                                     assert(ex == "*******************1.E+09");
   21246                                     assert(ios.width() == 0);
   21247                                 }
   21248                                 ios.width(25);
   21249                                 internal(ios);
   21250                                 {
   21251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21252                                     std::string ex(str, iter.base());
   21253                                     assert(ex == "*******************1.E+09");
   21254                                     assert(ios.width() == 0);
   21255                                 }
   21256                             }
   21257                             ios.imbue(lg);
   21258                             {
   21259                                 ios.width(0);
   21260                                 {
   21261                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21262                                     std::string ex(str, iter.base());
   21263                                     assert(ex == "1;E+09");
   21264                                     assert(ios.width() == 0);
   21265                                 }
   21266                                 ios.width(25);
   21267                                 left(ios);
   21268                                 {
   21269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21270                                     std::string ex(str, iter.base());
   21271                                     assert(ex == "1;E+09*******************");
   21272                                     assert(ios.width() == 0);
   21273                                 }
   21274                                 ios.width(25);
   21275                                 right(ios);
   21276                                 {
   21277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21278                                     std::string ex(str, iter.base());
   21279                                     assert(ex == "*******************1;E+09");
   21280                                     assert(ios.width() == 0);
   21281                                 }
   21282                                 ios.width(25);
   21283                                 internal(ios);
   21284                                 {
   21285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21286                                     std::string ex(str, iter.base());
   21287                                     assert(ex == "*******************1;E+09");
   21288                                     assert(ios.width() == 0);
   21289                                 }
   21290                             }
   21291                         }
   21292                     }
   21293                     showpos(ios);
   21294                     {
   21295                         noshowpoint(ios);
   21296                         {
   21297                             ios.imbue(lc);
   21298                             {
   21299                                 ios.width(0);
   21300                                 {
   21301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21302                                     std::string ex(str, iter.base());
   21303                                     assert(ex == "+1E+09");
   21304                                     assert(ios.width() == 0);
   21305                                 }
   21306                                 ios.width(25);
   21307                                 left(ios);
   21308                                 {
   21309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21310                                     std::string ex(str, iter.base());
   21311                                     assert(ex == "+1E+09*******************");
   21312                                     assert(ios.width() == 0);
   21313                                 }
   21314                                 ios.width(25);
   21315                                 right(ios);
   21316                                 {
   21317                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21318                                     std::string ex(str, iter.base());
   21319                                     assert(ex == "*******************+1E+09");
   21320                                     assert(ios.width() == 0);
   21321                                 }
   21322                                 ios.width(25);
   21323                                 internal(ios);
   21324                                 {
   21325                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21326                                     std::string ex(str, iter.base());
   21327                                     assert(ex == "+*******************1E+09");
   21328                                     assert(ios.width() == 0);
   21329                                 }
   21330                             }
   21331                             ios.imbue(lg);
   21332                             {
   21333                                 ios.width(0);
   21334                                 {
   21335                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21336                                     std::string ex(str, iter.base());
   21337                                     assert(ex == "+1E+09");
   21338                                     assert(ios.width() == 0);
   21339                                 }
   21340                                 ios.width(25);
   21341                                 left(ios);
   21342                                 {
   21343                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21344                                     std::string ex(str, iter.base());
   21345                                     assert(ex == "+1E+09*******************");
   21346                                     assert(ios.width() == 0);
   21347                                 }
   21348                                 ios.width(25);
   21349                                 right(ios);
   21350                                 {
   21351                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21352                                     std::string ex(str, iter.base());
   21353                                     assert(ex == "*******************+1E+09");
   21354                                     assert(ios.width() == 0);
   21355                                 }
   21356                                 ios.width(25);
   21357                                 internal(ios);
   21358                                 {
   21359                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21360                                     std::string ex(str, iter.base());
   21361                                     assert(ex == "+*******************1E+09");
   21362                                     assert(ios.width() == 0);
   21363                                 }
   21364                             }
   21365                         }
   21366                         showpoint(ios);
   21367                         {
   21368                             ios.imbue(lc);
   21369                             {
   21370                                 ios.width(0);
   21371                                 {
   21372                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21373                                     std::string ex(str, iter.base());
   21374                                     assert(ex == "+1.E+09");
   21375                                     assert(ios.width() == 0);
   21376                                 }
   21377                                 ios.width(25);
   21378                                 left(ios);
   21379                                 {
   21380                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21381                                     std::string ex(str, iter.base());
   21382                                     assert(ex == "+1.E+09******************");
   21383                                     assert(ios.width() == 0);
   21384                                 }
   21385                                 ios.width(25);
   21386                                 right(ios);
   21387                                 {
   21388                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21389                                     std::string ex(str, iter.base());
   21390                                     assert(ex == "******************+1.E+09");
   21391                                     assert(ios.width() == 0);
   21392                                 }
   21393                                 ios.width(25);
   21394                                 internal(ios);
   21395                                 {
   21396                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21397                                     std::string ex(str, iter.base());
   21398                                     assert(ex == "+******************1.E+09");
   21399                                     assert(ios.width() == 0);
   21400                                 }
   21401                             }
   21402                             ios.imbue(lg);
   21403                             {
   21404                                 ios.width(0);
   21405                                 {
   21406                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21407                                     std::string ex(str, iter.base());
   21408                                     assert(ex == "+1;E+09");
   21409                                     assert(ios.width() == 0);
   21410                                 }
   21411                                 ios.width(25);
   21412                                 left(ios);
   21413                                 {
   21414                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21415                                     std::string ex(str, iter.base());
   21416                                     assert(ex == "+1;E+09******************");
   21417                                     assert(ios.width() == 0);
   21418                                 }
   21419                                 ios.width(25);
   21420                                 right(ios);
   21421                                 {
   21422                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21423                                     std::string ex(str, iter.base());
   21424                                     assert(ex == "******************+1;E+09");
   21425                                     assert(ios.width() == 0);
   21426                                 }
   21427                                 ios.width(25);
   21428                                 internal(ios);
   21429                                 {
   21430                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21431                                     std::string ex(str, iter.base());
   21432                                     assert(ex == "+******************1;E+09");
   21433                                     assert(ios.width() == 0);
   21434                                 }
   21435                             }
   21436                         }
   21437                     }
   21438                 }
   21439             }
   21440             ios.precision(1);
   21441             {
   21442                 nouppercase(ios);
   21443                 {
   21444                     noshowpos(ios);
   21445                     {
   21446                         noshowpoint(ios);
   21447                         {
   21448                             ios.imbue(lc);
   21449                             {
   21450                                 ios.width(0);
   21451                                 {
   21452                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21453                                     std::string ex(str, iter.base());
   21454                                     assert(ex == "1.2e+09");
   21455                                     assert(ios.width() == 0);
   21456                                 }
   21457                                 ios.width(25);
   21458                                 left(ios);
   21459                                 {
   21460                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21461                                     std::string ex(str, iter.base());
   21462                                     assert(ex == "1.2e+09******************");
   21463                                     assert(ios.width() == 0);
   21464                                 }
   21465                                 ios.width(25);
   21466                                 right(ios);
   21467                                 {
   21468                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21469                                     std::string ex(str, iter.base());
   21470                                     assert(ex == "******************1.2e+09");
   21471                                     assert(ios.width() == 0);
   21472                                 }
   21473                                 ios.width(25);
   21474                                 internal(ios);
   21475                                 {
   21476                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21477                                     std::string ex(str, iter.base());
   21478                                     assert(ex == "******************1.2e+09");
   21479                                     assert(ios.width() == 0);
   21480                                 }
   21481                             }
   21482                             ios.imbue(lg);
   21483                             {
   21484                                 ios.width(0);
   21485                                 {
   21486                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21487                                     std::string ex(str, iter.base());
   21488                                     assert(ex == "1;2e+09");
   21489                                     assert(ios.width() == 0);
   21490                                 }
   21491                                 ios.width(25);
   21492                                 left(ios);
   21493                                 {
   21494                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21495                                     std::string ex(str, iter.base());
   21496                                     assert(ex == "1;2e+09******************");
   21497                                     assert(ios.width() == 0);
   21498                                 }
   21499                                 ios.width(25);
   21500                                 right(ios);
   21501                                 {
   21502                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21503                                     std::string ex(str, iter.base());
   21504                                     assert(ex == "******************1;2e+09");
   21505                                     assert(ios.width() == 0);
   21506                                 }
   21507                                 ios.width(25);
   21508                                 internal(ios);
   21509                                 {
   21510                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21511                                     std::string ex(str, iter.base());
   21512                                     assert(ex == "******************1;2e+09");
   21513                                     assert(ios.width() == 0);
   21514                                 }
   21515                             }
   21516                         }
   21517                         showpoint(ios);
   21518                         {
   21519                             ios.imbue(lc);
   21520                             {
   21521                                 ios.width(0);
   21522                                 {
   21523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21524                                     std::string ex(str, iter.base());
   21525                                     assert(ex == "1.2e+09");
   21526                                     assert(ios.width() == 0);
   21527                                 }
   21528                                 ios.width(25);
   21529                                 left(ios);
   21530                                 {
   21531                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21532                                     std::string ex(str, iter.base());
   21533                                     assert(ex == "1.2e+09******************");
   21534                                     assert(ios.width() == 0);
   21535                                 }
   21536                                 ios.width(25);
   21537                                 right(ios);
   21538                                 {
   21539                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21540                                     std::string ex(str, iter.base());
   21541                                     assert(ex == "******************1.2e+09");
   21542                                     assert(ios.width() == 0);
   21543                                 }
   21544                                 ios.width(25);
   21545                                 internal(ios);
   21546                                 {
   21547                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21548                                     std::string ex(str, iter.base());
   21549                                     assert(ex == "******************1.2e+09");
   21550                                     assert(ios.width() == 0);
   21551                                 }
   21552                             }
   21553                             ios.imbue(lg);
   21554                             {
   21555                                 ios.width(0);
   21556                                 {
   21557                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21558                                     std::string ex(str, iter.base());
   21559                                     assert(ex == "1;2e+09");
   21560                                     assert(ios.width() == 0);
   21561                                 }
   21562                                 ios.width(25);
   21563                                 left(ios);
   21564                                 {
   21565                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21566                                     std::string ex(str, iter.base());
   21567                                     assert(ex == "1;2e+09******************");
   21568                                     assert(ios.width() == 0);
   21569                                 }
   21570                                 ios.width(25);
   21571                                 right(ios);
   21572                                 {
   21573                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21574                                     std::string ex(str, iter.base());
   21575                                     assert(ex == "******************1;2e+09");
   21576                                     assert(ios.width() == 0);
   21577                                 }
   21578                                 ios.width(25);
   21579                                 internal(ios);
   21580                                 {
   21581                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21582                                     std::string ex(str, iter.base());
   21583                                     assert(ex == "******************1;2e+09");
   21584                                     assert(ios.width() == 0);
   21585                                 }
   21586                             }
   21587                         }
   21588                     }
   21589                     showpos(ios);
   21590                     {
   21591                         noshowpoint(ios);
   21592                         {
   21593                             ios.imbue(lc);
   21594                             {
   21595                                 ios.width(0);
   21596                                 {
   21597                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21598                                     std::string ex(str, iter.base());
   21599                                     assert(ex == "+1.2e+09");
   21600                                     assert(ios.width() == 0);
   21601                                 }
   21602                                 ios.width(25);
   21603                                 left(ios);
   21604                                 {
   21605                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21606                                     std::string ex(str, iter.base());
   21607                                     assert(ex == "+1.2e+09*****************");
   21608                                     assert(ios.width() == 0);
   21609                                 }
   21610                                 ios.width(25);
   21611                                 right(ios);
   21612                                 {
   21613                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21614                                     std::string ex(str, iter.base());
   21615                                     assert(ex == "*****************+1.2e+09");
   21616                                     assert(ios.width() == 0);
   21617                                 }
   21618                                 ios.width(25);
   21619                                 internal(ios);
   21620                                 {
   21621                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21622                                     std::string ex(str, iter.base());
   21623                                     assert(ex == "+*****************1.2e+09");
   21624                                     assert(ios.width() == 0);
   21625                                 }
   21626                             }
   21627                             ios.imbue(lg);
   21628                             {
   21629                                 ios.width(0);
   21630                                 {
   21631                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21632                                     std::string ex(str, iter.base());
   21633                                     assert(ex == "+1;2e+09");
   21634                                     assert(ios.width() == 0);
   21635                                 }
   21636                                 ios.width(25);
   21637                                 left(ios);
   21638                                 {
   21639                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21640                                     std::string ex(str, iter.base());
   21641                                     assert(ex == "+1;2e+09*****************");
   21642                                     assert(ios.width() == 0);
   21643                                 }
   21644                                 ios.width(25);
   21645                                 right(ios);
   21646                                 {
   21647                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21648                                     std::string ex(str, iter.base());
   21649                                     assert(ex == "*****************+1;2e+09");
   21650                                     assert(ios.width() == 0);
   21651                                 }
   21652                                 ios.width(25);
   21653                                 internal(ios);
   21654                                 {
   21655                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21656                                     std::string ex(str, iter.base());
   21657                                     assert(ex == "+*****************1;2e+09");
   21658                                     assert(ios.width() == 0);
   21659                                 }
   21660                             }
   21661                         }
   21662                         showpoint(ios);
   21663                         {
   21664                             ios.imbue(lc);
   21665                             {
   21666                                 ios.width(0);
   21667                                 {
   21668                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21669                                     std::string ex(str, iter.base());
   21670                                     assert(ex == "+1.2e+09");
   21671                                     assert(ios.width() == 0);
   21672                                 }
   21673                                 ios.width(25);
   21674                                 left(ios);
   21675                                 {
   21676                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21677                                     std::string ex(str, iter.base());
   21678                                     assert(ex == "+1.2e+09*****************");
   21679                                     assert(ios.width() == 0);
   21680                                 }
   21681                                 ios.width(25);
   21682                                 right(ios);
   21683                                 {
   21684                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21685                                     std::string ex(str, iter.base());
   21686                                     assert(ex == "*****************+1.2e+09");
   21687                                     assert(ios.width() == 0);
   21688                                 }
   21689                                 ios.width(25);
   21690                                 internal(ios);
   21691                                 {
   21692                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21693                                     std::string ex(str, iter.base());
   21694                                     assert(ex == "+*****************1.2e+09");
   21695                                     assert(ios.width() == 0);
   21696                                 }
   21697                             }
   21698                             ios.imbue(lg);
   21699                             {
   21700                                 ios.width(0);
   21701                                 {
   21702                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21703                                     std::string ex(str, iter.base());
   21704                                     assert(ex == "+1;2e+09");
   21705                                     assert(ios.width() == 0);
   21706                                 }
   21707                                 ios.width(25);
   21708                                 left(ios);
   21709                                 {
   21710                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21711                                     std::string ex(str, iter.base());
   21712                                     assert(ex == "+1;2e+09*****************");
   21713                                     assert(ios.width() == 0);
   21714                                 }
   21715                                 ios.width(25);
   21716                                 right(ios);
   21717                                 {
   21718                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21719                                     std::string ex(str, iter.base());
   21720                                     assert(ex == "*****************+1;2e+09");
   21721                                     assert(ios.width() == 0);
   21722                                 }
   21723                                 ios.width(25);
   21724                                 internal(ios);
   21725                                 {
   21726                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21727                                     std::string ex(str, iter.base());
   21728                                     assert(ex == "+*****************1;2e+09");
   21729                                     assert(ios.width() == 0);
   21730                                 }
   21731                             }
   21732                         }
   21733                     }
   21734                 }
   21735                 uppercase(ios);
   21736                 {
   21737                     noshowpos(ios);
   21738                     {
   21739                         noshowpoint(ios);
   21740                         {
   21741                             ios.imbue(lc);
   21742                             {
   21743                                 ios.width(0);
   21744                                 {
   21745                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21746                                     std::string ex(str, iter.base());
   21747                                     assert(ex == "1.2E+09");
   21748                                     assert(ios.width() == 0);
   21749                                 }
   21750                                 ios.width(25);
   21751                                 left(ios);
   21752                                 {
   21753                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21754                                     std::string ex(str, iter.base());
   21755                                     assert(ex == "1.2E+09******************");
   21756                                     assert(ios.width() == 0);
   21757                                 }
   21758                                 ios.width(25);
   21759                                 right(ios);
   21760                                 {
   21761                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21762                                     std::string ex(str, iter.base());
   21763                                     assert(ex == "******************1.2E+09");
   21764                                     assert(ios.width() == 0);
   21765                                 }
   21766                                 ios.width(25);
   21767                                 internal(ios);
   21768                                 {
   21769                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21770                                     std::string ex(str, iter.base());
   21771                                     assert(ex == "******************1.2E+09");
   21772                                     assert(ios.width() == 0);
   21773                                 }
   21774                             }
   21775                             ios.imbue(lg);
   21776                             {
   21777                                 ios.width(0);
   21778                                 {
   21779                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21780                                     std::string ex(str, iter.base());
   21781                                     assert(ex == "1;2E+09");
   21782                                     assert(ios.width() == 0);
   21783                                 }
   21784                                 ios.width(25);
   21785                                 left(ios);
   21786                                 {
   21787                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21788                                     std::string ex(str, iter.base());
   21789                                     assert(ex == "1;2E+09******************");
   21790                                     assert(ios.width() == 0);
   21791                                 }
   21792                                 ios.width(25);
   21793                                 right(ios);
   21794                                 {
   21795                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21796                                     std::string ex(str, iter.base());
   21797                                     assert(ex == "******************1;2E+09");
   21798                                     assert(ios.width() == 0);
   21799                                 }
   21800                                 ios.width(25);
   21801                                 internal(ios);
   21802                                 {
   21803                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21804                                     std::string ex(str, iter.base());
   21805                                     assert(ex == "******************1;2E+09");
   21806                                     assert(ios.width() == 0);
   21807                                 }
   21808                             }
   21809                         }
   21810                         showpoint(ios);
   21811                         {
   21812                             ios.imbue(lc);
   21813                             {
   21814                                 ios.width(0);
   21815                                 {
   21816                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21817                                     std::string ex(str, iter.base());
   21818                                     assert(ex == "1.2E+09");
   21819                                     assert(ios.width() == 0);
   21820                                 }
   21821                                 ios.width(25);
   21822                                 left(ios);
   21823                                 {
   21824                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21825                                     std::string ex(str, iter.base());
   21826                                     assert(ex == "1.2E+09******************");
   21827                                     assert(ios.width() == 0);
   21828                                 }
   21829                                 ios.width(25);
   21830                                 right(ios);
   21831                                 {
   21832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21833                                     std::string ex(str, iter.base());
   21834                                     assert(ex == "******************1.2E+09");
   21835                                     assert(ios.width() == 0);
   21836                                 }
   21837                                 ios.width(25);
   21838                                 internal(ios);
   21839                                 {
   21840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21841                                     std::string ex(str, iter.base());
   21842                                     assert(ex == "******************1.2E+09");
   21843                                     assert(ios.width() == 0);
   21844                                 }
   21845                             }
   21846                             ios.imbue(lg);
   21847                             {
   21848                                 ios.width(0);
   21849                                 {
   21850                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21851                                     std::string ex(str, iter.base());
   21852                                     assert(ex == "1;2E+09");
   21853                                     assert(ios.width() == 0);
   21854                                 }
   21855                                 ios.width(25);
   21856                                 left(ios);
   21857                                 {
   21858                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21859                                     std::string ex(str, iter.base());
   21860                                     assert(ex == "1;2E+09******************");
   21861                                     assert(ios.width() == 0);
   21862                                 }
   21863                                 ios.width(25);
   21864                                 right(ios);
   21865                                 {
   21866                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21867                                     std::string ex(str, iter.base());
   21868                                     assert(ex == "******************1;2E+09");
   21869                                     assert(ios.width() == 0);
   21870                                 }
   21871                                 ios.width(25);
   21872                                 internal(ios);
   21873                                 {
   21874                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21875                                     std::string ex(str, iter.base());
   21876                                     assert(ex == "******************1;2E+09");
   21877                                     assert(ios.width() == 0);
   21878                                 }
   21879                             }
   21880                         }
   21881                     }
   21882                     showpos(ios);
   21883                     {
   21884                         noshowpoint(ios);
   21885                         {
   21886                             ios.imbue(lc);
   21887                             {
   21888                                 ios.width(0);
   21889                                 {
   21890                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21891                                     std::string ex(str, iter.base());
   21892                                     assert(ex == "+1.2E+09");
   21893                                     assert(ios.width() == 0);
   21894                                 }
   21895                                 ios.width(25);
   21896                                 left(ios);
   21897                                 {
   21898                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21899                                     std::string ex(str, iter.base());
   21900                                     assert(ex == "+1.2E+09*****************");
   21901                                     assert(ios.width() == 0);
   21902                                 }
   21903                                 ios.width(25);
   21904                                 right(ios);
   21905                                 {
   21906                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21907                                     std::string ex(str, iter.base());
   21908                                     assert(ex == "*****************+1.2E+09");
   21909                                     assert(ios.width() == 0);
   21910                                 }
   21911                                 ios.width(25);
   21912                                 internal(ios);
   21913                                 {
   21914                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21915                                     std::string ex(str, iter.base());
   21916                                     assert(ex == "+*****************1.2E+09");
   21917                                     assert(ios.width() == 0);
   21918                                 }
   21919                             }
   21920                             ios.imbue(lg);
   21921                             {
   21922                                 ios.width(0);
   21923                                 {
   21924                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21925                                     std::string ex(str, iter.base());
   21926                                     assert(ex == "+1;2E+09");
   21927                                     assert(ios.width() == 0);
   21928                                 }
   21929                                 ios.width(25);
   21930                                 left(ios);
   21931                                 {
   21932                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21933                                     std::string ex(str, iter.base());
   21934                                     assert(ex == "+1;2E+09*****************");
   21935                                     assert(ios.width() == 0);
   21936                                 }
   21937                                 ios.width(25);
   21938                                 right(ios);
   21939                                 {
   21940                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21941                                     std::string ex(str, iter.base());
   21942                                     assert(ex == "*****************+1;2E+09");
   21943                                     assert(ios.width() == 0);
   21944                                 }
   21945                                 ios.width(25);
   21946                                 internal(ios);
   21947                                 {
   21948                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21949                                     std::string ex(str, iter.base());
   21950                                     assert(ex == "+*****************1;2E+09");
   21951                                     assert(ios.width() == 0);
   21952                                 }
   21953                             }
   21954                         }
   21955                         showpoint(ios);
   21956                         {
   21957                             ios.imbue(lc);
   21958                             {
   21959                                 ios.width(0);
   21960                                 {
   21961                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21962                                     std::string ex(str, iter.base());
   21963                                     assert(ex == "+1.2E+09");
   21964                                     assert(ios.width() == 0);
   21965                                 }
   21966                                 ios.width(25);
   21967                                 left(ios);
   21968                                 {
   21969                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21970                                     std::string ex(str, iter.base());
   21971                                     assert(ex == "+1.2E+09*****************");
   21972                                     assert(ios.width() == 0);
   21973                                 }
   21974                                 ios.width(25);
   21975                                 right(ios);
   21976                                 {
   21977                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21978                                     std::string ex(str, iter.base());
   21979                                     assert(ex == "*****************+1.2E+09");
   21980                                     assert(ios.width() == 0);
   21981                                 }
   21982                                 ios.width(25);
   21983                                 internal(ios);
   21984                                 {
   21985                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21986                                     std::string ex(str, iter.base());
   21987                                     assert(ex == "+*****************1.2E+09");
   21988                                     assert(ios.width() == 0);
   21989                                 }
   21990                             }
   21991                             ios.imbue(lg);
   21992                             {
   21993                                 ios.width(0);
   21994                                 {
   21995                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   21996                                     std::string ex(str, iter.base());
   21997                                     assert(ex == "+1;2E+09");
   21998                                     assert(ios.width() == 0);
   21999                                 }
   22000                                 ios.width(25);
   22001                                 left(ios);
   22002                                 {
   22003                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22004                                     std::string ex(str, iter.base());
   22005                                     assert(ex == "+1;2E+09*****************");
   22006                                     assert(ios.width() == 0);
   22007                                 }
   22008                                 ios.width(25);
   22009                                 right(ios);
   22010                                 {
   22011                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22012                                     std::string ex(str, iter.base());
   22013                                     assert(ex == "*****************+1;2E+09");
   22014                                     assert(ios.width() == 0);
   22015                                 }
   22016                                 ios.width(25);
   22017                                 internal(ios);
   22018                                 {
   22019                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22020                                     std::string ex(str, iter.base());
   22021                                     assert(ex == "+*****************1;2E+09");
   22022                                     assert(ios.width() == 0);
   22023                                 }
   22024                             }
   22025                         }
   22026                     }
   22027                 }
   22028             }
   22029             ios.precision(6);
   22030             {
   22031             }
   22032             ios.precision(16);
   22033             {
   22034             }
   22035             ios.precision(60);
   22036             {
   22037                 nouppercase(ios);
   22038                 {
   22039                     noshowpos(ios);
   22040                     {
   22041                         noshowpoint(ios);
   22042                         {
   22043                             ios.imbue(lc);
   22044                             {
   22045                                 ios.width(0);
   22046                                 {
   22047                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22048                                     std::string ex(str, iter.base());
   22049                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22050                                     assert(ios.width() == 0);
   22051                                 }
   22052                                 ios.width(25);
   22053                                 left(ios);
   22054                                 {
   22055                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22056                                     std::string ex(str, iter.base());
   22057                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22058                                     assert(ios.width() == 0);
   22059                                 }
   22060                                 ios.width(25);
   22061                                 right(ios);
   22062                                 {
   22063                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22064                                     std::string ex(str, iter.base());
   22065                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22066                                     assert(ios.width() == 0);
   22067                                 }
   22068                                 ios.width(25);
   22069                                 internal(ios);
   22070                                 {
   22071                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22072                                     std::string ex(str, iter.base());
   22073                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22074                                     assert(ios.width() == 0);
   22075                                 }
   22076                             }
   22077                             ios.imbue(lg);
   22078                             {
   22079                                 ios.width(0);
   22080                                 {
   22081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22082                                     std::string ex(str, iter.base());
   22083                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22084                                     assert(ios.width() == 0);
   22085                                 }
   22086                                 ios.width(25);
   22087                                 left(ios);
   22088                                 {
   22089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22090                                     std::string ex(str, iter.base());
   22091                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22092                                     assert(ios.width() == 0);
   22093                                 }
   22094                                 ios.width(25);
   22095                                 right(ios);
   22096                                 {
   22097                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22098                                     std::string ex(str, iter.base());
   22099                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22100                                     assert(ios.width() == 0);
   22101                                 }
   22102                                 ios.width(25);
   22103                                 internal(ios);
   22104                                 {
   22105                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22106                                     std::string ex(str, iter.base());
   22107                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22108                                     assert(ios.width() == 0);
   22109                                 }
   22110                             }
   22111                         }
   22112                         showpoint(ios);
   22113                         {
   22114                             ios.imbue(lc);
   22115                             {
   22116                                 ios.width(0);
   22117                                 {
   22118                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22119                                     std::string ex(str, iter.base());
   22120                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22121                                     assert(ios.width() == 0);
   22122                                 }
   22123                                 ios.width(25);
   22124                                 left(ios);
   22125                                 {
   22126                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22127                                     std::string ex(str, iter.base());
   22128                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22129                                     assert(ios.width() == 0);
   22130                                 }
   22131                                 ios.width(25);
   22132                                 right(ios);
   22133                                 {
   22134                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22135                                     std::string ex(str, iter.base());
   22136                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22137                                     assert(ios.width() == 0);
   22138                                 }
   22139                                 ios.width(25);
   22140                                 internal(ios);
   22141                                 {
   22142                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22143                                     std::string ex(str, iter.base());
   22144                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09");
   22145                                     assert(ios.width() == 0);
   22146                                 }
   22147                             }
   22148                             ios.imbue(lg);
   22149                             {
   22150                                 ios.width(0);
   22151                                 {
   22152                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22153                                     std::string ex(str, iter.base());
   22154                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22155                                     assert(ios.width() == 0);
   22156                                 }
   22157                                 ios.width(25);
   22158                                 left(ios);
   22159                                 {
   22160                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22161                                     std::string ex(str, iter.base());
   22162                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22163                                     assert(ios.width() == 0);
   22164                                 }
   22165                                 ios.width(25);
   22166                                 right(ios);
   22167                                 {
   22168                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22169                                     std::string ex(str, iter.base());
   22170                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22171                                     assert(ios.width() == 0);
   22172                                 }
   22173                                 ios.width(25);
   22174                                 internal(ios);
   22175                                 {
   22176                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22177                                     std::string ex(str, iter.base());
   22178                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09");
   22179                                     assert(ios.width() == 0);
   22180                                 }
   22181                             }
   22182                         }
   22183                     }
   22184                     showpos(ios);
   22185                     {
   22186                         noshowpoint(ios);
   22187                         {
   22188                             ios.imbue(lc);
   22189                             {
   22190                                 ios.width(0);
   22191                                 {
   22192                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22193                                     std::string ex(str, iter.base());
   22194                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22195                                     assert(ios.width() == 0);
   22196                                 }
   22197                                 ios.width(25);
   22198                                 left(ios);
   22199                                 {
   22200                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22201                                     std::string ex(str, iter.base());
   22202                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22203                                     assert(ios.width() == 0);
   22204                                 }
   22205                                 ios.width(25);
   22206                                 right(ios);
   22207                                 {
   22208                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22209                                     std::string ex(str, iter.base());
   22210                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22211                                     assert(ios.width() == 0);
   22212                                 }
   22213                                 ios.width(25);
   22214                                 internal(ios);
   22215                                 {
   22216                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22217                                     std::string ex(str, iter.base());
   22218                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22219                                     assert(ios.width() == 0);
   22220                                 }
   22221                             }
   22222                             ios.imbue(lg);
   22223                             {
   22224                                 ios.width(0);
   22225                                 {
   22226                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22227                                     std::string ex(str, iter.base());
   22228                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22229                                     assert(ios.width() == 0);
   22230                                 }
   22231                                 ios.width(25);
   22232                                 left(ios);
   22233                                 {
   22234                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22235                                     std::string ex(str, iter.base());
   22236                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22237                                     assert(ios.width() == 0);
   22238                                 }
   22239                                 ios.width(25);
   22240                                 right(ios);
   22241                                 {
   22242                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22243                                     std::string ex(str, iter.base());
   22244                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22245                                     assert(ios.width() == 0);
   22246                                 }
   22247                                 ios.width(25);
   22248                                 internal(ios);
   22249                                 {
   22250                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22251                                     std::string ex(str, iter.base());
   22252                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22253                                     assert(ios.width() == 0);
   22254                                 }
   22255                             }
   22256                         }
   22257                         showpoint(ios);
   22258                         {
   22259                             ios.imbue(lc);
   22260                             {
   22261                                 ios.width(0);
   22262                                 {
   22263                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22264                                     std::string ex(str, iter.base());
   22265                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22266                                     assert(ios.width() == 0);
   22267                                 }
   22268                                 ios.width(25);
   22269                                 left(ios);
   22270                                 {
   22271                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22272                                     std::string ex(str, iter.base());
   22273                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22274                                     assert(ios.width() == 0);
   22275                                 }
   22276                                 ios.width(25);
   22277                                 right(ios);
   22278                                 {
   22279                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22280                                     std::string ex(str, iter.base());
   22281                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22282                                     assert(ios.width() == 0);
   22283                                 }
   22284                                 ios.width(25);
   22285                                 internal(ios);
   22286                                 {
   22287                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22288                                     std::string ex(str, iter.base());
   22289                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09");
   22290                                     assert(ios.width() == 0);
   22291                                 }
   22292                             }
   22293                             ios.imbue(lg);
   22294                             {
   22295                                 ios.width(0);
   22296                                 {
   22297                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22298                                     std::string ex(str, iter.base());
   22299                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22300                                     assert(ios.width() == 0);
   22301                                 }
   22302                                 ios.width(25);
   22303                                 left(ios);
   22304                                 {
   22305                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22306                                     std::string ex(str, iter.base());
   22307                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22308                                     assert(ios.width() == 0);
   22309                                 }
   22310                                 ios.width(25);
   22311                                 right(ios);
   22312                                 {
   22313                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22314                                     std::string ex(str, iter.base());
   22315                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22316                                     assert(ios.width() == 0);
   22317                                 }
   22318                                 ios.width(25);
   22319                                 internal(ios);
   22320                                 {
   22321                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22322                                     std::string ex(str, iter.base());
   22323                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09");
   22324                                     assert(ios.width() == 0);
   22325                                 }
   22326                             }
   22327                         }
   22328                     }
   22329                 }
   22330                 uppercase(ios);
   22331                 {
   22332                     noshowpos(ios);
   22333                     {
   22334                         noshowpoint(ios);
   22335                         {
   22336                             ios.imbue(lc);
   22337                             {
   22338                                 ios.width(0);
   22339                                 {
   22340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22341                                     std::string ex(str, iter.base());
   22342                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22343                                     assert(ios.width() == 0);
   22344                                 }
   22345                                 ios.width(25);
   22346                                 left(ios);
   22347                                 {
   22348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22349                                     std::string ex(str, iter.base());
   22350                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22351                                     assert(ios.width() == 0);
   22352                                 }
   22353                                 ios.width(25);
   22354                                 right(ios);
   22355                                 {
   22356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22357                                     std::string ex(str, iter.base());
   22358                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22359                                     assert(ios.width() == 0);
   22360                                 }
   22361                                 ios.width(25);
   22362                                 internal(ios);
   22363                                 {
   22364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22365                                     std::string ex(str, iter.base());
   22366                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22367                                     assert(ios.width() == 0);
   22368                                 }
   22369                             }
   22370                             ios.imbue(lg);
   22371                             {
   22372                                 ios.width(0);
   22373                                 {
   22374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22375                                     std::string ex(str, iter.base());
   22376                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22377                                     assert(ios.width() == 0);
   22378                                 }
   22379                                 ios.width(25);
   22380                                 left(ios);
   22381                                 {
   22382                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22383                                     std::string ex(str, iter.base());
   22384                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22385                                     assert(ios.width() == 0);
   22386                                 }
   22387                                 ios.width(25);
   22388                                 right(ios);
   22389                                 {
   22390                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22391                                     std::string ex(str, iter.base());
   22392                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22393                                     assert(ios.width() == 0);
   22394                                 }
   22395                                 ios.width(25);
   22396                                 internal(ios);
   22397                                 {
   22398                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22399                                     std::string ex(str, iter.base());
   22400                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22401                                     assert(ios.width() == 0);
   22402                                 }
   22403                             }
   22404                         }
   22405                         showpoint(ios);
   22406                         {
   22407                             ios.imbue(lc);
   22408                             {
   22409                                 ios.width(0);
   22410                                 {
   22411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22412                                     std::string ex(str, iter.base());
   22413                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22414                                     assert(ios.width() == 0);
   22415                                 }
   22416                                 ios.width(25);
   22417                                 left(ios);
   22418                                 {
   22419                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22420                                     std::string ex(str, iter.base());
   22421                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22422                                     assert(ios.width() == 0);
   22423                                 }
   22424                                 ios.width(25);
   22425                                 right(ios);
   22426                                 {
   22427                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22428                                     std::string ex(str, iter.base());
   22429                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22430                                     assert(ios.width() == 0);
   22431                                 }
   22432                                 ios.width(25);
   22433                                 internal(ios);
   22434                                 {
   22435                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22436                                     std::string ex(str, iter.base());
   22437                                     assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09");
   22438                                     assert(ios.width() == 0);
   22439                                 }
   22440                             }
   22441                             ios.imbue(lg);
   22442                             {
   22443                                 ios.width(0);
   22444                                 {
   22445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22446                                     std::string ex(str, iter.base());
   22447                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22448                                     assert(ios.width() == 0);
   22449                                 }
   22450                                 ios.width(25);
   22451                                 left(ios);
   22452                                 {
   22453                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22454                                     std::string ex(str, iter.base());
   22455                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22456                                     assert(ios.width() == 0);
   22457                                 }
   22458                                 ios.width(25);
   22459                                 right(ios);
   22460                                 {
   22461                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22462                                     std::string ex(str, iter.base());
   22463                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22464                                     assert(ios.width() == 0);
   22465                                 }
   22466                                 ios.width(25);
   22467                                 internal(ios);
   22468                                 {
   22469                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22470                                     std::string ex(str, iter.base());
   22471                                     assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09");
   22472                                     assert(ios.width() == 0);
   22473                                 }
   22474                             }
   22475                         }
   22476                     }
   22477                     showpos(ios);
   22478                     {
   22479                         noshowpoint(ios);
   22480                         {
   22481                             ios.imbue(lc);
   22482                             {
   22483                                 ios.width(0);
   22484                                 {
   22485                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22486                                     std::string ex(str, iter.base());
   22487                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22488                                     assert(ios.width() == 0);
   22489                                 }
   22490                                 ios.width(25);
   22491                                 left(ios);
   22492                                 {
   22493                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22494                                     std::string ex(str, iter.base());
   22495                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22496                                     assert(ios.width() == 0);
   22497                                 }
   22498                                 ios.width(25);
   22499                                 right(ios);
   22500                                 {
   22501                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22502                                     std::string ex(str, iter.base());
   22503                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22504                                     assert(ios.width() == 0);
   22505                                 }
   22506                                 ios.width(25);
   22507                                 internal(ios);
   22508                                 {
   22509                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22510                                     std::string ex(str, iter.base());
   22511                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22512                                     assert(ios.width() == 0);
   22513                                 }
   22514                             }
   22515                             ios.imbue(lg);
   22516                             {
   22517                                 ios.width(0);
   22518                                 {
   22519                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22520                                     std::string ex(str, iter.base());
   22521                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22522                                     assert(ios.width() == 0);
   22523                                 }
   22524                                 ios.width(25);
   22525                                 left(ios);
   22526                                 {
   22527                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22528                                     std::string ex(str, iter.base());
   22529                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22530                                     assert(ios.width() == 0);
   22531                                 }
   22532                                 ios.width(25);
   22533                                 right(ios);
   22534                                 {
   22535                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22536                                     std::string ex(str, iter.base());
   22537                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22538                                     assert(ios.width() == 0);
   22539                                 }
   22540                                 ios.width(25);
   22541                                 internal(ios);
   22542                                 {
   22543                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22544                                     std::string ex(str, iter.base());
   22545                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22546                                     assert(ios.width() == 0);
   22547                                 }
   22548                             }
   22549                         }
   22550                         showpoint(ios);
   22551                         {
   22552                             ios.imbue(lc);
   22553                             {
   22554                                 ios.width(0);
   22555                                 {
   22556                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22557                                     std::string ex(str, iter.base());
   22558                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22559                                     assert(ios.width() == 0);
   22560                                 }
   22561                                 ios.width(25);
   22562                                 left(ios);
   22563                                 {
   22564                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22565                                     std::string ex(str, iter.base());
   22566                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22567                                     assert(ios.width() == 0);
   22568                                 }
   22569                                 ios.width(25);
   22570                                 right(ios);
   22571                                 {
   22572                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22573                                     std::string ex(str, iter.base());
   22574                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22575                                     assert(ios.width() == 0);
   22576                                 }
   22577                                 ios.width(25);
   22578                                 internal(ios);
   22579                                 {
   22580                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22581                                     std::string ex(str, iter.base());
   22582                                     assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09");
   22583                                     assert(ios.width() == 0);
   22584                                 }
   22585                             }
   22586                             ios.imbue(lg);
   22587                             {
   22588                                 ios.width(0);
   22589                                 {
   22590                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22591                                     std::string ex(str, iter.base());
   22592                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22593                                     assert(ios.width() == 0);
   22594                                 }
   22595                                 ios.width(25);
   22596                                 left(ios);
   22597                                 {
   22598                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22599                                     std::string ex(str, iter.base());
   22600                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22601                                     assert(ios.width() == 0);
   22602                                 }
   22603                                 ios.width(25);
   22604                                 right(ios);
   22605                                 {
   22606                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22607                                     std::string ex(str, iter.base());
   22608                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22609                                     assert(ios.width() == 0);
   22610                                 }
   22611                                 ios.width(25);
   22612                                 internal(ios);
   22613                                 {
   22614                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22615                                     std::string ex(str, iter.base());
   22616                                     assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09");
   22617                                     assert(ios.width() == 0);
   22618                                 }
   22619                             }
   22620                         }
   22621                     }
   22622                 }
   22623             }
   22624         }
   22625     }
   22626 }
   22627 
   22628 void test11()
   22629 {
   22630     char str[200];
   22631     output_iterator<char*> iter;
   22632     std::locale lc = std::locale::classic();
   22633     std::locale lg(lc, new my_numpunct);
   22634     const my_facet f(1);
   22635     {
   22636         long double v = -0.;
   22637         std::ios ios(0);
   22638         hexfloat(ios);
   22639         // %a
   22640         {
   22641             ios.precision(0);
   22642             {
   22643                 nouppercase(ios);
   22644                 {
   22645                     noshowpos(ios);
   22646                     {
   22647                         noshowpoint(ios);
   22648                         {
   22649                             ios.imbue(lc);
   22650                             {
   22651                                 ios.width(0);
   22652                                 {
   22653                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22654                                     std::string ex(str, iter.base());
   22655                                     assert(ex == "-0x0p+0");
   22656                                     assert(ios.width() == 0);
   22657                                 }
   22658                                 ios.width(25);
   22659                                 left(ios);
   22660                                 {
   22661                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22662                                     std::string ex(str, iter.base());
   22663                                     assert(ex == "-0x0p+0******************");
   22664                                     assert(ios.width() == 0);
   22665                                 }
   22666                                 ios.width(25);
   22667                                 right(ios);
   22668                                 {
   22669                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22670                                     std::string ex(str, iter.base());
   22671                                     assert(ex == "******************-0x0p+0");
   22672                                     assert(ios.width() == 0);
   22673                                 }
   22674                                 ios.width(25);
   22675                                 internal(ios);
   22676                                 {
   22677                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22678                                     std::string ex(str, iter.base());
   22679                                     assert(ex == "-******************0x0p+0");
   22680                                     assert(ios.width() == 0);
   22681                                 }
   22682                             }
   22683                             ios.imbue(lg);
   22684                             {
   22685                                 ios.width(0);
   22686                                 {
   22687                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22688                                     std::string ex(str, iter.base());
   22689                                     assert(ex == "-0x0p+0");
   22690                                     assert(ios.width() == 0);
   22691                                 }
   22692                                 ios.width(25);
   22693                                 left(ios);
   22694                                 {
   22695                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22696                                     std::string ex(str, iter.base());
   22697                                     assert(ex == "-0x0p+0******************");
   22698                                     assert(ios.width() == 0);
   22699                                 }
   22700                                 ios.width(25);
   22701                                 right(ios);
   22702                                 {
   22703                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22704                                     std::string ex(str, iter.base());
   22705                                     assert(ex == "******************-0x0p+0");
   22706                                     assert(ios.width() == 0);
   22707                                 }
   22708                                 ios.width(25);
   22709                                 internal(ios);
   22710                                 {
   22711                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22712                                     std::string ex(str, iter.base());
   22713                                     assert(ex == "-******************0x0p+0");
   22714                                     assert(ios.width() == 0);
   22715                                 }
   22716                             }
   22717                         }
   22718                         showpoint(ios);
   22719                         {
   22720                             ios.imbue(lc);
   22721                             {
   22722                                 ios.width(0);
   22723                                 {
   22724                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22725                                     std::string ex(str, iter.base());
   22726                                     assert(ex == "-0x0.p+0");
   22727                                     assert(ios.width() == 0);
   22728                                 }
   22729                                 ios.width(25);
   22730                                 left(ios);
   22731                                 {
   22732                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22733                                     std::string ex(str, iter.base());
   22734                                     assert(ex == "-0x0.p+0*****************");
   22735                                     assert(ios.width() == 0);
   22736                                 }
   22737                                 ios.width(25);
   22738                                 right(ios);
   22739                                 {
   22740                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22741                                     std::string ex(str, iter.base());
   22742                                     assert(ex == "*****************-0x0.p+0");
   22743                                     assert(ios.width() == 0);
   22744                                 }
   22745                                 ios.width(25);
   22746                                 internal(ios);
   22747                                 {
   22748                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22749                                     std::string ex(str, iter.base());
   22750                                     assert(ex == "-*****************0x0.p+0");
   22751                                     assert(ios.width() == 0);
   22752                                 }
   22753                             }
   22754                             ios.imbue(lg);
   22755                             {
   22756                                 ios.width(0);
   22757                                 {
   22758                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22759                                     std::string ex(str, iter.base());
   22760                                     assert(ex == "-0x0;p+0");
   22761                                     assert(ios.width() == 0);
   22762                                 }
   22763                                 ios.width(25);
   22764                                 left(ios);
   22765                                 {
   22766                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22767                                     std::string ex(str, iter.base());
   22768                                     assert(ex == "-0x0;p+0*****************");
   22769                                     assert(ios.width() == 0);
   22770                                 }
   22771                                 ios.width(25);
   22772                                 right(ios);
   22773                                 {
   22774                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22775                                     std::string ex(str, iter.base());
   22776                                     assert(ex == "*****************-0x0;p+0");
   22777                                     assert(ios.width() == 0);
   22778                                 }
   22779                                 ios.width(25);
   22780                                 internal(ios);
   22781                                 {
   22782                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22783                                     std::string ex(str, iter.base());
   22784                                     assert(ex == "-*****************0x0;p+0");
   22785                                     assert(ios.width() == 0);
   22786                                 }
   22787                             }
   22788                         }
   22789                     }
   22790                     showpos(ios);
   22791                     {
   22792                         noshowpoint(ios);
   22793                         {
   22794                             ios.imbue(lc);
   22795                             {
   22796                                 ios.width(0);
   22797                                 {
   22798                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22799                                     std::string ex(str, iter.base());
   22800                                     assert(ex == "-0x0p+0");
   22801                                     assert(ios.width() == 0);
   22802                                 }
   22803                                 ios.width(25);
   22804                                 left(ios);
   22805                                 {
   22806                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22807                                     std::string ex(str, iter.base());
   22808                                     assert(ex == "-0x0p+0******************");
   22809                                     assert(ios.width() == 0);
   22810                                 }
   22811                                 ios.width(25);
   22812                                 right(ios);
   22813                                 {
   22814                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22815                                     std::string ex(str, iter.base());
   22816                                     assert(ex == "******************-0x0p+0");
   22817                                     assert(ios.width() == 0);
   22818                                 }
   22819                                 ios.width(25);
   22820                                 internal(ios);
   22821                                 {
   22822                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22823                                     std::string ex(str, iter.base());
   22824                                     assert(ex == "-******************0x0p+0");
   22825                                     assert(ios.width() == 0);
   22826                                 }
   22827                             }
   22828                             ios.imbue(lg);
   22829                             {
   22830                                 ios.width(0);
   22831                                 {
   22832                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22833                                     std::string ex(str, iter.base());
   22834                                     assert(ex == "-0x0p+0");
   22835                                     assert(ios.width() == 0);
   22836                                 }
   22837                                 ios.width(25);
   22838                                 left(ios);
   22839                                 {
   22840                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22841                                     std::string ex(str, iter.base());
   22842                                     assert(ex == "-0x0p+0******************");
   22843                                     assert(ios.width() == 0);
   22844                                 }
   22845                                 ios.width(25);
   22846                                 right(ios);
   22847                                 {
   22848                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22849                                     std::string ex(str, iter.base());
   22850                                     assert(ex == "******************-0x0p+0");
   22851                                     assert(ios.width() == 0);
   22852                                 }
   22853                                 ios.width(25);
   22854                                 internal(ios);
   22855                                 {
   22856                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22857                                     std::string ex(str, iter.base());
   22858                                     assert(ex == "-******************0x0p+0");
   22859                                     assert(ios.width() == 0);
   22860                                 }
   22861                             }
   22862                         }
   22863                         showpoint(ios);
   22864                         {
   22865                             ios.imbue(lc);
   22866                             {
   22867                                 ios.width(0);
   22868                                 {
   22869                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22870                                     std::string ex(str, iter.base());
   22871                                     assert(ex == "-0x0.p+0");
   22872                                     assert(ios.width() == 0);
   22873                                 }
   22874                                 ios.width(25);
   22875                                 left(ios);
   22876                                 {
   22877                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22878                                     std::string ex(str, iter.base());
   22879                                     assert(ex == "-0x0.p+0*****************");
   22880                                     assert(ios.width() == 0);
   22881                                 }
   22882                                 ios.width(25);
   22883                                 right(ios);
   22884                                 {
   22885                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22886                                     std::string ex(str, iter.base());
   22887                                     assert(ex == "*****************-0x0.p+0");
   22888                                     assert(ios.width() == 0);
   22889                                 }
   22890                                 ios.width(25);
   22891                                 internal(ios);
   22892                                 {
   22893                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22894                                     std::string ex(str, iter.base());
   22895                                     assert(ex == "-*****************0x0.p+0");
   22896                                     assert(ios.width() == 0);
   22897                                 }
   22898                             }
   22899                             ios.imbue(lg);
   22900                             {
   22901                                 ios.width(0);
   22902                                 {
   22903                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22904                                     std::string ex(str, iter.base());
   22905                                     assert(ex == "-0x0;p+0");
   22906                                     assert(ios.width() == 0);
   22907                                 }
   22908                                 ios.width(25);
   22909                                 left(ios);
   22910                                 {
   22911                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22912                                     std::string ex(str, iter.base());
   22913                                     assert(ex == "-0x0;p+0*****************");
   22914                                     assert(ios.width() == 0);
   22915                                 }
   22916                                 ios.width(25);
   22917                                 right(ios);
   22918                                 {
   22919                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22920                                     std::string ex(str, iter.base());
   22921                                     assert(ex == "*****************-0x0;p+0");
   22922                                     assert(ios.width() == 0);
   22923                                 }
   22924                                 ios.width(25);
   22925                                 internal(ios);
   22926                                 {
   22927                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22928                                     std::string ex(str, iter.base());
   22929                                     assert(ex == "-*****************0x0;p+0");
   22930                                     assert(ios.width() == 0);
   22931                                 }
   22932                             }
   22933                         }
   22934                     }
   22935                 }
   22936                 uppercase(ios);
   22937                 {
   22938                     noshowpos(ios);
   22939                     {
   22940                         noshowpoint(ios);
   22941                         {
   22942                             ios.imbue(lc);
   22943                             {
   22944                                 ios.width(0);
   22945                                 {
   22946                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22947                                     std::string ex(str, iter.base());
   22948                                     assert(ex == "-0X0P+0");
   22949                                     assert(ios.width() == 0);
   22950                                 }
   22951                                 ios.width(25);
   22952                                 left(ios);
   22953                                 {
   22954                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22955                                     std::string ex(str, iter.base());
   22956                                     assert(ex == "-0X0P+0******************");
   22957                                     assert(ios.width() == 0);
   22958                                 }
   22959                                 ios.width(25);
   22960                                 right(ios);
   22961                                 {
   22962                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22963                                     std::string ex(str, iter.base());
   22964                                     assert(ex == "******************-0X0P+0");
   22965                                     assert(ios.width() == 0);
   22966                                 }
   22967                                 ios.width(25);
   22968                                 internal(ios);
   22969                                 {
   22970                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22971                                     std::string ex(str, iter.base());
   22972                                     assert(ex == "-******************0X0P+0");
   22973                                     assert(ios.width() == 0);
   22974                                 }
   22975                             }
   22976                             ios.imbue(lg);
   22977                             {
   22978                                 ios.width(0);
   22979                                 {
   22980                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22981                                     std::string ex(str, iter.base());
   22982                                     assert(ex == "-0X0P+0");
   22983                                     assert(ios.width() == 0);
   22984                                 }
   22985                                 ios.width(25);
   22986                                 left(ios);
   22987                                 {
   22988                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22989                                     std::string ex(str, iter.base());
   22990                                     assert(ex == "-0X0P+0******************");
   22991                                     assert(ios.width() == 0);
   22992                                 }
   22993                                 ios.width(25);
   22994                                 right(ios);
   22995                                 {
   22996                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   22997                                     std::string ex(str, iter.base());
   22998                                     assert(ex == "******************-0X0P+0");
   22999                                     assert(ios.width() == 0);
   23000                                 }
   23001                                 ios.width(25);
   23002                                 internal(ios);
   23003                                 {
   23004                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23005                                     std::string ex(str, iter.base());
   23006                                     assert(ex == "-******************0X0P+0");
   23007                                     assert(ios.width() == 0);
   23008                                 }
   23009                             }
   23010                         }
   23011                         showpoint(ios);
   23012                         {
   23013                             ios.imbue(lc);
   23014                             {
   23015                                 ios.width(0);
   23016                                 {
   23017                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23018                                     std::string ex(str, iter.base());
   23019                                     assert(ex == "-0X0.P+0");
   23020                                     assert(ios.width() == 0);
   23021                                 }
   23022                                 ios.width(25);
   23023                                 left(ios);
   23024                                 {
   23025                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23026                                     std::string ex(str, iter.base());
   23027                                     assert(ex == "-0X0.P+0*****************");
   23028                                     assert(ios.width() == 0);
   23029                                 }
   23030                                 ios.width(25);
   23031                                 right(ios);
   23032                                 {
   23033                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23034                                     std::string ex(str, iter.base());
   23035                                     assert(ex == "*****************-0X0.P+0");
   23036                                     assert(ios.width() == 0);
   23037                                 }
   23038                                 ios.width(25);
   23039                                 internal(ios);
   23040                                 {
   23041                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23042                                     std::string ex(str, iter.base());
   23043                                     assert(ex == "-*****************0X0.P+0");
   23044                                     assert(ios.width() == 0);
   23045                                 }
   23046                             }
   23047                             ios.imbue(lg);
   23048                             {
   23049                                 ios.width(0);
   23050                                 {
   23051                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23052                                     std::string ex(str, iter.base());
   23053                                     assert(ex == "-0X0;P+0");
   23054                                     assert(ios.width() == 0);
   23055                                 }
   23056                                 ios.width(25);
   23057                                 left(ios);
   23058                                 {
   23059                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23060                                     std::string ex(str, iter.base());
   23061                                     assert(ex == "-0X0;P+0*****************");
   23062                                     assert(ios.width() == 0);
   23063                                 }
   23064                                 ios.width(25);
   23065                                 right(ios);
   23066                                 {
   23067                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23068                                     std::string ex(str, iter.base());
   23069                                     assert(ex == "*****************-0X0;P+0");
   23070                                     assert(ios.width() == 0);
   23071                                 }
   23072                                 ios.width(25);
   23073                                 internal(ios);
   23074                                 {
   23075                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23076                                     std::string ex(str, iter.base());
   23077                                     assert(ex == "-*****************0X0;P+0");
   23078                                     assert(ios.width() == 0);
   23079                                 }
   23080                             }
   23081                         }
   23082                     }
   23083                     showpos(ios);
   23084                     {
   23085                         noshowpoint(ios);
   23086                         {
   23087                             ios.imbue(lc);
   23088                             {
   23089                                 ios.width(0);
   23090                                 {
   23091                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23092                                     std::string ex(str, iter.base());
   23093                                     assert(ex == "-0X0P+0");
   23094                                     assert(ios.width() == 0);
   23095                                 }
   23096                                 ios.width(25);
   23097                                 left(ios);
   23098                                 {
   23099                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23100                                     std::string ex(str, iter.base());
   23101                                     assert(ex == "-0X0P+0******************");
   23102                                     assert(ios.width() == 0);
   23103                                 }
   23104                                 ios.width(25);
   23105                                 right(ios);
   23106                                 {
   23107                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23108                                     std::string ex(str, iter.base());
   23109                                     assert(ex == "******************-0X0P+0");
   23110                                     assert(ios.width() == 0);
   23111                                 }
   23112                                 ios.width(25);
   23113                                 internal(ios);
   23114                                 {
   23115                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23116                                     std::string ex(str, iter.base());
   23117                                     assert(ex == "-******************0X0P+0");
   23118                                     assert(ios.width() == 0);
   23119                                 }
   23120                             }
   23121                             ios.imbue(lg);
   23122                             {
   23123                                 ios.width(0);
   23124                                 {
   23125                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23126                                     std::string ex(str, iter.base());
   23127                                     assert(ex == "-0X0P+0");
   23128                                     assert(ios.width() == 0);
   23129                                 }
   23130                                 ios.width(25);
   23131                                 left(ios);
   23132                                 {
   23133                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23134                                     std::string ex(str, iter.base());
   23135                                     assert(ex == "-0X0P+0******************");
   23136                                     assert(ios.width() == 0);
   23137                                 }
   23138                                 ios.width(25);
   23139                                 right(ios);
   23140                                 {
   23141                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23142                                     std::string ex(str, iter.base());
   23143                                     assert(ex == "******************-0X0P+0");
   23144                                     assert(ios.width() == 0);
   23145                                 }
   23146                                 ios.width(25);
   23147                                 internal(ios);
   23148                                 {
   23149                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23150                                     std::string ex(str, iter.base());
   23151                                     assert(ex == "-******************0X0P+0");
   23152                                     assert(ios.width() == 0);
   23153                                 }
   23154                             }
   23155                         }
   23156                         showpoint(ios);
   23157                         {
   23158                             ios.imbue(lc);
   23159                             {
   23160                                 ios.width(0);
   23161                                 {
   23162                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23163                                     std::string ex(str, iter.base());
   23164                                     assert(ex == "-0X0.P+0");
   23165                                     assert(ios.width() == 0);
   23166                                 }
   23167                                 ios.width(25);
   23168                                 left(ios);
   23169                                 {
   23170                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23171                                     std::string ex(str, iter.base());
   23172                                     assert(ex == "-0X0.P+0*****************");
   23173                                     assert(ios.width() == 0);
   23174                                 }
   23175                                 ios.width(25);
   23176                                 right(ios);
   23177                                 {
   23178                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23179                                     std::string ex(str, iter.base());
   23180                                     assert(ex == "*****************-0X0.P+0");
   23181                                     assert(ios.width() == 0);
   23182                                 }
   23183                                 ios.width(25);
   23184                                 internal(ios);
   23185                                 {
   23186                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23187                                     std::string ex(str, iter.base());
   23188                                     assert(ex == "-*****************0X0.P+0");
   23189                                     assert(ios.width() == 0);
   23190                                 }
   23191                             }
   23192                             ios.imbue(lg);
   23193                             {
   23194                                 ios.width(0);
   23195                                 {
   23196                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23197                                     std::string ex(str, iter.base());
   23198                                     assert(ex == "-0X0;P+0");
   23199                                     assert(ios.width() == 0);
   23200                                 }
   23201                                 ios.width(25);
   23202                                 left(ios);
   23203                                 {
   23204                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23205                                     std::string ex(str, iter.base());
   23206                                     assert(ex == "-0X0;P+0*****************");
   23207                                     assert(ios.width() == 0);
   23208                                 }
   23209                                 ios.width(25);
   23210                                 right(ios);
   23211                                 {
   23212                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23213                                     std::string ex(str, iter.base());
   23214                                     assert(ex == "*****************-0X0;P+0");
   23215                                     assert(ios.width() == 0);
   23216                                 }
   23217                                 ios.width(25);
   23218                                 internal(ios);
   23219                                 {
   23220                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23221                                     std::string ex(str, iter.base());
   23222                                     assert(ex == "-*****************0X0;P+0");
   23223                                     assert(ios.width() == 0);
   23224                                 }
   23225                             }
   23226                         }
   23227                     }
   23228                 }
   23229             }
   23230             ios.precision(1);
   23231             {
   23232                 nouppercase(ios);
   23233                 {
   23234                     noshowpos(ios);
   23235                     {
   23236                         noshowpoint(ios);
   23237                         {
   23238                             ios.imbue(lc);
   23239                             {
   23240                                 ios.width(0);
   23241                                 {
   23242                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23243                                     std::string ex(str, iter.base());
   23244                                     assert(ex == "-0x0p+0");
   23245                                     assert(ios.width() == 0);
   23246                                 }
   23247                                 ios.width(25);
   23248                                 left(ios);
   23249                                 {
   23250                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23251                                     std::string ex(str, iter.base());
   23252                                     assert(ex == "-0x0p+0******************");
   23253                                     assert(ios.width() == 0);
   23254                                 }
   23255                                 ios.width(25);
   23256                                 right(ios);
   23257                                 {
   23258                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23259                                     std::string ex(str, iter.base());
   23260                                     assert(ex == "******************-0x0p+0");
   23261                                     assert(ios.width() == 0);
   23262                                 }
   23263                                 ios.width(25);
   23264                                 internal(ios);
   23265                                 {
   23266                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23267                                     std::string ex(str, iter.base());
   23268                                     assert(ex == "-******************0x0p+0");
   23269                                     assert(ios.width() == 0);
   23270                                 }
   23271                             }
   23272                             ios.imbue(lg);
   23273                             {
   23274                                 ios.width(0);
   23275                                 {
   23276                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23277                                     std::string ex(str, iter.base());
   23278                                     assert(ex == "-0x0p+0");
   23279                                     assert(ios.width() == 0);
   23280                                 }
   23281                                 ios.width(25);
   23282                                 left(ios);
   23283                                 {
   23284                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23285                                     std::string ex(str, iter.base());
   23286                                     assert(ex == "-0x0p+0******************");
   23287                                     assert(ios.width() == 0);
   23288                                 }
   23289                                 ios.width(25);
   23290                                 right(ios);
   23291                                 {
   23292                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23293                                     std::string ex(str, iter.base());
   23294                                     assert(ex == "******************-0x0p+0");
   23295                                     assert(ios.width() == 0);
   23296                                 }
   23297                                 ios.width(25);
   23298                                 internal(ios);
   23299                                 {
   23300                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23301                                     std::string ex(str, iter.base());
   23302                                     assert(ex == "-******************0x0p+0");
   23303                                     assert(ios.width() == 0);
   23304                                 }
   23305                             }
   23306                         }
   23307                         showpoint(ios);
   23308                         {
   23309                             ios.imbue(lc);
   23310                             {
   23311                                 ios.width(0);
   23312                                 {
   23313                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23314                                     std::string ex(str, iter.base());
   23315                                     assert(ex == "-0x0.p+0");
   23316                                     assert(ios.width() == 0);
   23317                                 }
   23318                                 ios.width(25);
   23319                                 left(ios);
   23320                                 {
   23321                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23322                                     std::string ex(str, iter.base());
   23323                                     assert(ex == "-0x0.p+0*****************");
   23324                                     assert(ios.width() == 0);
   23325                                 }
   23326                                 ios.width(25);
   23327                                 right(ios);
   23328                                 {
   23329                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23330                                     std::string ex(str, iter.base());
   23331                                     assert(ex == "*****************-0x0.p+0");
   23332                                     assert(ios.width() == 0);
   23333                                 }
   23334                                 ios.width(25);
   23335                                 internal(ios);
   23336                                 {
   23337                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23338                                     std::string ex(str, iter.base());
   23339                                     assert(ex == "-*****************0x0.p+0");
   23340                                     assert(ios.width() == 0);
   23341                                 }
   23342                             }
   23343                             ios.imbue(lg);
   23344                             {
   23345                                 ios.width(0);
   23346                                 {
   23347                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23348                                     std::string ex(str, iter.base());
   23349                                     assert(ex == "-0x0;p+0");
   23350                                     assert(ios.width() == 0);
   23351                                 }
   23352                                 ios.width(25);
   23353                                 left(ios);
   23354                                 {
   23355                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23356                                     std::string ex(str, iter.base());
   23357                                     assert(ex == "-0x0;p+0*****************");
   23358                                     assert(ios.width() == 0);
   23359                                 }
   23360                                 ios.width(25);
   23361                                 right(ios);
   23362                                 {
   23363                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23364                                     std::string ex(str, iter.base());
   23365                                     assert(ex == "*****************-0x0;p+0");
   23366                                     assert(ios.width() == 0);
   23367                                 }
   23368                                 ios.width(25);
   23369                                 internal(ios);
   23370                                 {
   23371                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23372                                     std::string ex(str, iter.base());
   23373                                     assert(ex == "-*****************0x0;p+0");
   23374                                     assert(ios.width() == 0);
   23375                                 }
   23376                             }
   23377                         }
   23378                     }
   23379                     showpos(ios);
   23380                     {
   23381                         noshowpoint(ios);
   23382                         {
   23383                             ios.imbue(lc);
   23384                             {
   23385                                 ios.width(0);
   23386                                 {
   23387                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23388                                     std::string ex(str, iter.base());
   23389                                     assert(ex == "-0x0p+0");
   23390                                     assert(ios.width() == 0);
   23391                                 }
   23392                                 ios.width(25);
   23393                                 left(ios);
   23394                                 {
   23395                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23396                                     std::string ex(str, iter.base());
   23397                                     assert(ex == "-0x0p+0******************");
   23398                                     assert(ios.width() == 0);
   23399                                 }
   23400                                 ios.width(25);
   23401                                 right(ios);
   23402                                 {
   23403                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23404                                     std::string ex(str, iter.base());
   23405                                     assert(ex == "******************-0x0p+0");
   23406                                     assert(ios.width() == 0);
   23407                                 }
   23408                                 ios.width(25);
   23409                                 internal(ios);
   23410                                 {
   23411                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23412                                     std::string ex(str, iter.base());
   23413                                     assert(ex == "-******************0x0p+0");
   23414                                     assert(ios.width() == 0);
   23415                                 }
   23416                             }
   23417                             ios.imbue(lg);
   23418                             {
   23419                                 ios.width(0);
   23420                                 {
   23421                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23422                                     std::string ex(str, iter.base());
   23423                                     assert(ex == "-0x0p+0");
   23424                                     assert(ios.width() == 0);
   23425                                 }
   23426                                 ios.width(25);
   23427                                 left(ios);
   23428                                 {
   23429                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23430                                     std::string ex(str, iter.base());
   23431                                     assert(ex == "-0x0p+0******************");
   23432                                     assert(ios.width() == 0);
   23433                                 }
   23434                                 ios.width(25);
   23435                                 right(ios);
   23436                                 {
   23437                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23438                                     std::string ex(str, iter.base());
   23439                                     assert(ex == "******************-0x0p+0");
   23440                                     assert(ios.width() == 0);
   23441                                 }
   23442                                 ios.width(25);
   23443                                 internal(ios);
   23444                                 {
   23445                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23446                                     std::string ex(str, iter.base());
   23447                                     assert(ex == "-******************0x0p+0");
   23448                                     assert(ios.width() == 0);
   23449                                 }
   23450                             }
   23451                         }
   23452                         showpoint(ios);
   23453                         {
   23454                             ios.imbue(lc);
   23455                             {
   23456                                 ios.width(0);
   23457                                 {
   23458                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23459                                     std::string ex(str, iter.base());
   23460                                     assert(ex == "-0x0.p+0");
   23461                                     assert(ios.width() == 0);
   23462                                 }
   23463                                 ios.width(25);
   23464                                 left(ios);
   23465                                 {
   23466                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23467                                     std::string ex(str, iter.base());
   23468                                     assert(ex == "-0x0.p+0*****************");
   23469                                     assert(ios.width() == 0);
   23470                                 }
   23471                                 ios.width(25);
   23472                                 right(ios);
   23473                                 {
   23474                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23475                                     std::string ex(str, iter.base());
   23476                                     assert(ex == "*****************-0x0.p+0");
   23477                                     assert(ios.width() == 0);
   23478                                 }
   23479                                 ios.width(25);
   23480                                 internal(ios);
   23481                                 {
   23482                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23483                                     std::string ex(str, iter.base());
   23484                                     assert(ex == "-*****************0x0.p+0");
   23485                                     assert(ios.width() == 0);
   23486                                 }
   23487                             }
   23488                             ios.imbue(lg);
   23489                             {
   23490                                 ios.width(0);
   23491                                 {
   23492                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23493                                     std::string ex(str, iter.base());
   23494                                     assert(ex == "-0x0;p+0");
   23495                                     assert(ios.width() == 0);
   23496                                 }
   23497                                 ios.width(25);
   23498                                 left(ios);
   23499                                 {
   23500                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23501                                     std::string ex(str, iter.base());
   23502                                     assert(ex == "-0x0;p+0*****************");
   23503                                     assert(ios.width() == 0);
   23504                                 }
   23505                                 ios.width(25);
   23506                                 right(ios);
   23507                                 {
   23508                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23509                                     std::string ex(str, iter.base());
   23510                                     assert(ex == "*****************-0x0;p+0");
   23511                                     assert(ios.width() == 0);
   23512                                 }
   23513                                 ios.width(25);
   23514                                 internal(ios);
   23515                                 {
   23516                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23517                                     std::string ex(str, iter.base());
   23518                                     assert(ex == "-*****************0x0;p+0");
   23519                                     assert(ios.width() == 0);
   23520                                 }
   23521                             }
   23522                         }
   23523                     }
   23524                 }
   23525                 uppercase(ios);
   23526                 {
   23527                     noshowpos(ios);
   23528                     {
   23529                         noshowpoint(ios);
   23530                         {
   23531                             ios.imbue(lc);
   23532                             {
   23533                                 ios.width(0);
   23534                                 {
   23535                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23536                                     std::string ex(str, iter.base());
   23537                                     assert(ex == "-0X0P+0");
   23538                                     assert(ios.width() == 0);
   23539                                 }
   23540                                 ios.width(25);
   23541                                 left(ios);
   23542                                 {
   23543                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23544                                     std::string ex(str, iter.base());
   23545                                     assert(ex == "-0X0P+0******************");
   23546                                     assert(ios.width() == 0);
   23547                                 }
   23548                                 ios.width(25);
   23549                                 right(ios);
   23550                                 {
   23551                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23552                                     std::string ex(str, iter.base());
   23553                                     assert(ex == "******************-0X0P+0");
   23554                                     assert(ios.width() == 0);
   23555                                 }
   23556                                 ios.width(25);
   23557                                 internal(ios);
   23558                                 {
   23559                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23560                                     std::string ex(str, iter.base());
   23561                                     assert(ex == "-******************0X0P+0");
   23562                                     assert(ios.width() == 0);
   23563                                 }
   23564                             }
   23565                             ios.imbue(lg);
   23566                             {
   23567                                 ios.width(0);
   23568                                 {
   23569                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23570                                     std::string ex(str, iter.base());
   23571                                     assert(ex == "-0X0P+0");
   23572                                     assert(ios.width() == 0);
   23573                                 }
   23574                                 ios.width(25);
   23575                                 left(ios);
   23576                                 {
   23577                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23578                                     std::string ex(str, iter.base());
   23579                                     assert(ex == "-0X0P+0******************");
   23580                                     assert(ios.width() == 0);
   23581                                 }
   23582                                 ios.width(25);
   23583                                 right(ios);
   23584                                 {
   23585                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23586                                     std::string ex(str, iter.base());
   23587                                     assert(ex == "******************-0X0P+0");
   23588                                     assert(ios.width() == 0);
   23589                                 }
   23590                                 ios.width(25);
   23591                                 internal(ios);
   23592                                 {
   23593                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23594                                     std::string ex(str, iter.base());
   23595                                     assert(ex == "-******************0X0P+0");
   23596                                     assert(ios.width() == 0);
   23597                                 }
   23598                             }
   23599                         }
   23600                         showpoint(ios);
   23601                         {
   23602                             ios.imbue(lc);
   23603                             {
   23604                                 ios.width(0);
   23605                                 {
   23606                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23607                                     std::string ex(str, iter.base());
   23608                                     assert(ex == "-0X0.P+0");
   23609                                     assert(ios.width() == 0);
   23610                                 }
   23611                                 ios.width(25);
   23612                                 left(ios);
   23613                                 {
   23614                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23615                                     std::string ex(str, iter.base());
   23616                                     assert(ex == "-0X0.P+0*****************");
   23617                                     assert(ios.width() == 0);
   23618                                 }
   23619                                 ios.width(25);
   23620                                 right(ios);
   23621                                 {
   23622                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23623                                     std::string ex(str, iter.base());
   23624                                     assert(ex == "*****************-0X0.P+0");
   23625                                     assert(ios.width() == 0);
   23626                                 }
   23627                                 ios.width(25);
   23628                                 internal(ios);
   23629                                 {
   23630                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23631                                     std::string ex(str, iter.base());
   23632                                     assert(ex == "-*****************0X0.P+0");
   23633                                     assert(ios.width() == 0);
   23634                                 }
   23635                             }
   23636                             ios.imbue(lg);
   23637                             {
   23638                                 ios.width(0);
   23639                                 {
   23640                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23641                                     std::string ex(str, iter.base());
   23642                                     assert(ex == "-0X0;P+0");
   23643                                     assert(ios.width() == 0);
   23644                                 }
   23645                                 ios.width(25);
   23646                                 left(ios);
   23647                                 {
   23648                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23649                                     std::string ex(str, iter.base());
   23650                                     assert(ex == "-0X0;P+0*****************");
   23651                                     assert(ios.width() == 0);
   23652                                 }
   23653                                 ios.width(25);
   23654                                 right(ios);
   23655                                 {
   23656                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23657                                     std::string ex(str, iter.base());
   23658                                     assert(ex == "*****************-0X0;P+0");
   23659                                     assert(ios.width() == 0);
   23660                                 }
   23661                                 ios.width(25);
   23662                                 internal(ios);
   23663                                 {
   23664                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23665                                     std::string ex(str, iter.base());
   23666                                     assert(ex == "-*****************0X0;P+0");
   23667                                     assert(ios.width() == 0);
   23668                                 }
   23669                             }
   23670                         }
   23671                     }
   23672                     showpos(ios);
   23673                     {
   23674                         noshowpoint(ios);
   23675                         {
   23676                             ios.imbue(lc);
   23677                             {
   23678                                 ios.width(0);
   23679                                 {
   23680                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23681                                     std::string ex(str, iter.base());
   23682                                     assert(ex == "-0X0P+0");
   23683                                     assert(ios.width() == 0);
   23684                                 }
   23685                                 ios.width(25);
   23686                                 left(ios);
   23687                                 {
   23688                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23689                                     std::string ex(str, iter.base());
   23690                                     assert(ex == "-0X0P+0******************");
   23691                                     assert(ios.width() == 0);
   23692                                 }
   23693                                 ios.width(25);
   23694                                 right(ios);
   23695                                 {
   23696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23697                                     std::string ex(str, iter.base());
   23698                                     assert(ex == "******************-0X0P+0");
   23699                                     assert(ios.width() == 0);
   23700                                 }
   23701                                 ios.width(25);
   23702                                 internal(ios);
   23703                                 {
   23704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23705                                     std::string ex(str, iter.base());
   23706                                     assert(ex == "-******************0X0P+0");
   23707                                     assert(ios.width() == 0);
   23708                                 }
   23709                             }
   23710                             ios.imbue(lg);
   23711                             {
   23712                                 ios.width(0);
   23713                                 {
   23714                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23715                                     std::string ex(str, iter.base());
   23716                                     assert(ex == "-0X0P+0");
   23717                                     assert(ios.width() == 0);
   23718                                 }
   23719                                 ios.width(25);
   23720                                 left(ios);
   23721                                 {
   23722                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23723                                     std::string ex(str, iter.base());
   23724                                     assert(ex == "-0X0P+0******************");
   23725                                     assert(ios.width() == 0);
   23726                                 }
   23727                                 ios.width(25);
   23728                                 right(ios);
   23729                                 {
   23730                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23731                                     std::string ex(str, iter.base());
   23732                                     assert(ex == "******************-0X0P+0");
   23733                                     assert(ios.width() == 0);
   23734                                 }
   23735                                 ios.width(25);
   23736                                 internal(ios);
   23737                                 {
   23738                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23739                                     std::string ex(str, iter.base());
   23740                                     assert(ex == "-******************0X0P+0");
   23741                                     assert(ios.width() == 0);
   23742                                 }
   23743                             }
   23744                         }
   23745                         showpoint(ios);
   23746                         {
   23747                             ios.imbue(lc);
   23748                             {
   23749                                 ios.width(0);
   23750                                 {
   23751                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23752                                     std::string ex(str, iter.base());
   23753                                     assert(ex == "-0X0.P+0");
   23754                                     assert(ios.width() == 0);
   23755                                 }
   23756                                 ios.width(25);
   23757                                 left(ios);
   23758                                 {
   23759                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23760                                     std::string ex(str, iter.base());
   23761                                     assert(ex == "-0X0.P+0*****************");
   23762                                     assert(ios.width() == 0);
   23763                                 }
   23764                                 ios.width(25);
   23765                                 right(ios);
   23766                                 {
   23767                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23768                                     std::string ex(str, iter.base());
   23769                                     assert(ex == "*****************-0X0.P+0");
   23770                                     assert(ios.width() == 0);
   23771                                 }
   23772                                 ios.width(25);
   23773                                 internal(ios);
   23774                                 {
   23775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23776                                     std::string ex(str, iter.base());
   23777                                     assert(ex == "-*****************0X0.P+0");
   23778                                     assert(ios.width() == 0);
   23779                                 }
   23780                             }
   23781                             ios.imbue(lg);
   23782                             {
   23783                                 ios.width(0);
   23784                                 {
   23785                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23786                                     std::string ex(str, iter.base());
   23787                                     assert(ex == "-0X0;P+0");
   23788                                     assert(ios.width() == 0);
   23789                                 }
   23790                                 ios.width(25);
   23791                                 left(ios);
   23792                                 {
   23793                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23794                                     std::string ex(str, iter.base());
   23795                                     assert(ex == "-0X0;P+0*****************");
   23796                                     assert(ios.width() == 0);
   23797                                 }
   23798                                 ios.width(25);
   23799                                 right(ios);
   23800                                 {
   23801                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23802                                     std::string ex(str, iter.base());
   23803                                     assert(ex == "*****************-0X0;P+0");
   23804                                     assert(ios.width() == 0);
   23805                                 }
   23806                                 ios.width(25);
   23807                                 internal(ios);
   23808                                 {
   23809                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23810                                     std::string ex(str, iter.base());
   23811                                     assert(ex == "-*****************0X0;P+0");
   23812                                     assert(ios.width() == 0);
   23813                                 }
   23814                             }
   23815                         }
   23816                     }
   23817                 }
   23818             }
   23819             ios.precision(6);
   23820             {
   23821                 nouppercase(ios);
   23822                 {
   23823                     noshowpos(ios);
   23824                     {
   23825                         noshowpoint(ios);
   23826                         {
   23827                             ios.imbue(lc);
   23828                             {
   23829                                 ios.width(0);
   23830                                 {
   23831                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23832                                     std::string ex(str, iter.base());
   23833                                     assert(ex == "-0x0p+0");
   23834                                     assert(ios.width() == 0);
   23835                                 }
   23836                                 ios.width(25);
   23837                                 left(ios);
   23838                                 {
   23839                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23840                                     std::string ex(str, iter.base());
   23841                                     assert(ex == "-0x0p+0******************");
   23842                                     assert(ios.width() == 0);
   23843                                 }
   23844                                 ios.width(25);
   23845                                 right(ios);
   23846                                 {
   23847                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23848                                     std::string ex(str, iter.base());
   23849                                     assert(ex == "******************-0x0p+0");
   23850                                     assert(ios.width() == 0);
   23851                                 }
   23852                                 ios.width(25);
   23853                                 internal(ios);
   23854                                 {
   23855                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23856                                     std::string ex(str, iter.base());
   23857                                     assert(ex == "-******************0x0p+0");
   23858                                     assert(ios.width() == 0);
   23859                                 }
   23860                             }
   23861                             ios.imbue(lg);
   23862                             {
   23863                                 ios.width(0);
   23864                                 {
   23865                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23866                                     std::string ex(str, iter.base());
   23867                                     assert(ex == "-0x0p+0");
   23868                                     assert(ios.width() == 0);
   23869                                 }
   23870                                 ios.width(25);
   23871                                 left(ios);
   23872                                 {
   23873                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23874                                     std::string ex(str, iter.base());
   23875                                     assert(ex == "-0x0p+0******************");
   23876                                     assert(ios.width() == 0);
   23877                                 }
   23878                                 ios.width(25);
   23879                                 right(ios);
   23880                                 {
   23881                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23882                                     std::string ex(str, iter.base());
   23883                                     assert(ex == "******************-0x0p+0");
   23884                                     assert(ios.width() == 0);
   23885                                 }
   23886                                 ios.width(25);
   23887                                 internal(ios);
   23888                                 {
   23889                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23890                                     std::string ex(str, iter.base());
   23891                                     assert(ex == "-******************0x0p+0");
   23892                                     assert(ios.width() == 0);
   23893                                 }
   23894                             }
   23895                         }
   23896                         showpoint(ios);
   23897                         {
   23898                             ios.imbue(lc);
   23899                             {
   23900                                 ios.width(0);
   23901                                 {
   23902                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23903                                     std::string ex(str, iter.base());
   23904                                     assert(ex == "-0x0.p+0");
   23905                                     assert(ios.width() == 0);
   23906                                 }
   23907                                 ios.width(25);
   23908                                 left(ios);
   23909                                 {
   23910                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23911                                     std::string ex(str, iter.base());
   23912                                     assert(ex == "-0x0.p+0*****************");
   23913                                     assert(ios.width() == 0);
   23914                                 }
   23915                                 ios.width(25);
   23916                                 right(ios);
   23917                                 {
   23918                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23919                                     std::string ex(str, iter.base());
   23920                                     assert(ex == "*****************-0x0.p+0");
   23921                                     assert(ios.width() == 0);
   23922                                 }
   23923                                 ios.width(25);
   23924                                 internal(ios);
   23925                                 {
   23926                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23927                                     std::string ex(str, iter.base());
   23928                                     assert(ex == "-*****************0x0.p+0");
   23929                                     assert(ios.width() == 0);
   23930                                 }
   23931                             }
   23932                             ios.imbue(lg);
   23933                             {
   23934                                 ios.width(0);
   23935                                 {
   23936                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23937                                     std::string ex(str, iter.base());
   23938                                     assert(ex == "-0x0;p+0");
   23939                                     assert(ios.width() == 0);
   23940                                 }
   23941                                 ios.width(25);
   23942                                 left(ios);
   23943                                 {
   23944                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23945                                     std::string ex(str, iter.base());
   23946                                     assert(ex == "-0x0;p+0*****************");
   23947                                     assert(ios.width() == 0);
   23948                                 }
   23949                                 ios.width(25);
   23950                                 right(ios);
   23951                                 {
   23952                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23953                                     std::string ex(str, iter.base());
   23954                                     assert(ex == "*****************-0x0;p+0");
   23955                                     assert(ios.width() == 0);
   23956                                 }
   23957                                 ios.width(25);
   23958                                 internal(ios);
   23959                                 {
   23960                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23961                                     std::string ex(str, iter.base());
   23962                                     assert(ex == "-*****************0x0;p+0");
   23963                                     assert(ios.width() == 0);
   23964                                 }
   23965                             }
   23966                         }
   23967                     }
   23968                     showpos(ios);
   23969                     {
   23970                         noshowpoint(ios);
   23971                         {
   23972                             ios.imbue(lc);
   23973                             {
   23974                                 ios.width(0);
   23975                                 {
   23976                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23977                                     std::string ex(str, iter.base());
   23978                                     assert(ex == "-0x0p+0");
   23979                                     assert(ios.width() == 0);
   23980                                 }
   23981                                 ios.width(25);
   23982                                 left(ios);
   23983                                 {
   23984                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23985                                     std::string ex(str, iter.base());
   23986                                     assert(ex == "-0x0p+0******************");
   23987                                     assert(ios.width() == 0);
   23988                                 }
   23989                                 ios.width(25);
   23990                                 right(ios);
   23991                                 {
   23992                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   23993                                     std::string ex(str, iter.base());
   23994                                     assert(ex == "******************-0x0p+0");
   23995                                     assert(ios.width() == 0);
   23996                                 }
   23997                                 ios.width(25);
   23998                                 internal(ios);
   23999                                 {
   24000                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24001                                     std::string ex(str, iter.base());
   24002                                     assert(ex == "-******************0x0p+0");
   24003                                     assert(ios.width() == 0);
   24004                                 }
   24005                             }
   24006                             ios.imbue(lg);
   24007                             {
   24008                                 ios.width(0);
   24009                                 {
   24010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24011                                     std::string ex(str, iter.base());
   24012                                     assert(ex == "-0x0p+0");
   24013                                     assert(ios.width() == 0);
   24014                                 }
   24015                                 ios.width(25);
   24016                                 left(ios);
   24017                                 {
   24018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24019                                     std::string ex(str, iter.base());
   24020                                     assert(ex == "-0x0p+0******************");
   24021                                     assert(ios.width() == 0);
   24022                                 }
   24023                                 ios.width(25);
   24024                                 right(ios);
   24025                                 {
   24026                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24027                                     std::string ex(str, iter.base());
   24028                                     assert(ex == "******************-0x0p+0");
   24029                                     assert(ios.width() == 0);
   24030                                 }
   24031                                 ios.width(25);
   24032                                 internal(ios);
   24033                                 {
   24034                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24035                                     std::string ex(str, iter.base());
   24036                                     assert(ex == "-******************0x0p+0");
   24037                                     assert(ios.width() == 0);
   24038                                 }
   24039                             }
   24040                         }
   24041                         showpoint(ios);
   24042                         {
   24043                             ios.imbue(lc);
   24044                             {
   24045                                 ios.width(0);
   24046                                 {
   24047                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24048                                     std::string ex(str, iter.base());
   24049                                     assert(ex == "-0x0.p+0");
   24050                                     assert(ios.width() == 0);
   24051                                 }
   24052                                 ios.width(25);
   24053                                 left(ios);
   24054                                 {
   24055                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24056                                     std::string ex(str, iter.base());
   24057                                     assert(ex == "-0x0.p+0*****************");
   24058                                     assert(ios.width() == 0);
   24059                                 }
   24060                                 ios.width(25);
   24061                                 right(ios);
   24062                                 {
   24063                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24064                                     std::string ex(str, iter.base());
   24065                                     assert(ex == "*****************-0x0.p+0");
   24066                                     assert(ios.width() == 0);
   24067                                 }
   24068                                 ios.width(25);
   24069                                 internal(ios);
   24070                                 {
   24071                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24072                                     std::string ex(str, iter.base());
   24073                                     assert(ex == "-*****************0x0.p+0");
   24074                                     assert(ios.width() == 0);
   24075                                 }
   24076                             }
   24077                             ios.imbue(lg);
   24078                             {
   24079                                 ios.width(0);
   24080                                 {
   24081                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24082                                     std::string ex(str, iter.base());
   24083                                     assert(ex == "-0x0;p+0");
   24084                                     assert(ios.width() == 0);
   24085                                 }
   24086                                 ios.width(25);
   24087                                 left(ios);
   24088                                 {
   24089                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24090                                     std::string ex(str, iter.base());
   24091                                     assert(ex == "-0x0;p+0*****************");
   24092                                     assert(ios.width() == 0);
   24093                                 }
   24094                                 ios.width(25);
   24095                                 right(ios);
   24096                                 {
   24097                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24098                                     std::string ex(str, iter.base());
   24099                                     assert(ex == "*****************-0x0;p+0");
   24100                                     assert(ios.width() == 0);
   24101                                 }
   24102                                 ios.width(25);
   24103                                 internal(ios);
   24104                                 {
   24105                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24106                                     std::string ex(str, iter.base());
   24107                                     assert(ex == "-*****************0x0;p+0");
   24108                                     assert(ios.width() == 0);
   24109                                 }
   24110                             }
   24111                         }
   24112                     }
   24113                 }
   24114                 uppercase(ios);
   24115                 {
   24116                     noshowpos(ios);
   24117                     {
   24118                         noshowpoint(ios);
   24119                         {
   24120                             ios.imbue(lc);
   24121                             {
   24122                                 ios.width(0);
   24123                                 {
   24124                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24125                                     std::string ex(str, iter.base());
   24126                                     assert(ex == "-0X0P+0");
   24127                                     assert(ios.width() == 0);
   24128                                 }
   24129                                 ios.width(25);
   24130                                 left(ios);
   24131                                 {
   24132                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24133                                     std::string ex(str, iter.base());
   24134                                     assert(ex == "-0X0P+0******************");
   24135                                     assert(ios.width() == 0);
   24136                                 }
   24137                                 ios.width(25);
   24138                                 right(ios);
   24139                                 {
   24140                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24141                                     std::string ex(str, iter.base());
   24142                                     assert(ex == "******************-0X0P+0");
   24143                                     assert(ios.width() == 0);
   24144                                 }
   24145                                 ios.width(25);
   24146                                 internal(ios);
   24147                                 {
   24148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24149                                     std::string ex(str, iter.base());
   24150                                     assert(ex == "-******************0X0P+0");
   24151                                     assert(ios.width() == 0);
   24152                                 }
   24153                             }
   24154                             ios.imbue(lg);
   24155                             {
   24156                                 ios.width(0);
   24157                                 {
   24158                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24159                                     std::string ex(str, iter.base());
   24160                                     assert(ex == "-0X0P+0");
   24161                                     assert(ios.width() == 0);
   24162                                 }
   24163                                 ios.width(25);
   24164                                 left(ios);
   24165                                 {
   24166                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24167                                     std::string ex(str, iter.base());
   24168                                     assert(ex == "-0X0P+0******************");
   24169                                     assert(ios.width() == 0);
   24170                                 }
   24171                                 ios.width(25);
   24172                                 right(ios);
   24173                                 {
   24174                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24175                                     std::string ex(str, iter.base());
   24176                                     assert(ex == "******************-0X0P+0");
   24177                                     assert(ios.width() == 0);
   24178                                 }
   24179                                 ios.width(25);
   24180                                 internal(ios);
   24181                                 {
   24182                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24183                                     std::string ex(str, iter.base());
   24184                                     assert(ex == "-******************0X0P+0");
   24185                                     assert(ios.width() == 0);
   24186                                 }
   24187                             }
   24188                         }
   24189                         showpoint(ios);
   24190                         {
   24191                             ios.imbue(lc);
   24192                             {
   24193                                 ios.width(0);
   24194                                 {
   24195                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24196                                     std::string ex(str, iter.base());
   24197                                     assert(ex == "-0X0.P+0");
   24198                                     assert(ios.width() == 0);
   24199                                 }
   24200                                 ios.width(25);
   24201                                 left(ios);
   24202                                 {
   24203                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24204                                     std::string ex(str, iter.base());
   24205                                     assert(ex == "-0X0.P+0*****************");
   24206                                     assert(ios.width() == 0);
   24207                                 }
   24208                                 ios.width(25);
   24209                                 right(ios);
   24210                                 {
   24211                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24212                                     std::string ex(str, iter.base());
   24213                                     assert(ex == "*****************-0X0.P+0");
   24214                                     assert(ios.width() == 0);
   24215                                 }
   24216                                 ios.width(25);
   24217                                 internal(ios);
   24218                                 {
   24219                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24220                                     std::string ex(str, iter.base());
   24221                                     assert(ex == "-*****************0X0.P+0");
   24222                                     assert(ios.width() == 0);
   24223                                 }
   24224                             }
   24225                             ios.imbue(lg);
   24226                             {
   24227                                 ios.width(0);
   24228                                 {
   24229                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24230                                     std::string ex(str, iter.base());
   24231                                     assert(ex == "-0X0;P+0");
   24232                                     assert(ios.width() == 0);
   24233                                 }
   24234                                 ios.width(25);
   24235                                 left(ios);
   24236                                 {
   24237                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24238                                     std::string ex(str, iter.base());
   24239                                     assert(ex == "-0X0;P+0*****************");
   24240                                     assert(ios.width() == 0);
   24241                                 }
   24242                                 ios.width(25);
   24243                                 right(ios);
   24244                                 {
   24245                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24246                                     std::string ex(str, iter.base());
   24247                                     assert(ex == "*****************-0X0;P+0");
   24248                                     assert(ios.width() == 0);
   24249                                 }
   24250                                 ios.width(25);
   24251                                 internal(ios);
   24252                                 {
   24253                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24254                                     std::string ex(str, iter.base());
   24255                                     assert(ex == "-*****************0X0;P+0");
   24256                                     assert(ios.width() == 0);
   24257                                 }
   24258                             }
   24259                         }
   24260                     }
   24261                     showpos(ios);
   24262                     {
   24263                         noshowpoint(ios);
   24264                         {
   24265                             ios.imbue(lc);
   24266                             {
   24267                                 ios.width(0);
   24268                                 {
   24269                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24270                                     std::string ex(str, iter.base());
   24271                                     assert(ex == "-0X0P+0");
   24272                                     assert(ios.width() == 0);
   24273                                 }
   24274                                 ios.width(25);
   24275                                 left(ios);
   24276                                 {
   24277                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24278                                     std::string ex(str, iter.base());
   24279                                     assert(ex == "-0X0P+0******************");
   24280                                     assert(ios.width() == 0);
   24281                                 }
   24282                                 ios.width(25);
   24283                                 right(ios);
   24284                                 {
   24285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24286                                     std::string ex(str, iter.base());
   24287                                     assert(ex == "******************-0X0P+0");
   24288                                     assert(ios.width() == 0);
   24289                                 }
   24290                                 ios.width(25);
   24291                                 internal(ios);
   24292                                 {
   24293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24294                                     std::string ex(str, iter.base());
   24295                                     assert(ex == "-******************0X0P+0");
   24296                                     assert(ios.width() == 0);
   24297                                 }
   24298                             }
   24299                             ios.imbue(lg);
   24300                             {
   24301                                 ios.width(0);
   24302                                 {
   24303                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24304                                     std::string ex(str, iter.base());
   24305                                     assert(ex == "-0X0P+0");
   24306                                     assert(ios.width() == 0);
   24307                                 }
   24308                                 ios.width(25);
   24309                                 left(ios);
   24310                                 {
   24311                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24312                                     std::string ex(str, iter.base());
   24313                                     assert(ex == "-0X0P+0******************");
   24314                                     assert(ios.width() == 0);
   24315                                 }
   24316                                 ios.width(25);
   24317                                 right(ios);
   24318                                 {
   24319                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24320                                     std::string ex(str, iter.base());
   24321                                     assert(ex == "******************-0X0P+0");
   24322                                     assert(ios.width() == 0);
   24323                                 }
   24324                                 ios.width(25);
   24325                                 internal(ios);
   24326                                 {
   24327                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24328                                     std::string ex(str, iter.base());
   24329                                     assert(ex == "-******************0X0P+0");
   24330                                     assert(ios.width() == 0);
   24331                                 }
   24332                             }
   24333                         }
   24334                         showpoint(ios);
   24335                         {
   24336                             ios.imbue(lc);
   24337                             {
   24338                                 ios.width(0);
   24339                                 {
   24340                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24341                                     std::string ex(str, iter.base());
   24342                                     assert(ex == "-0X0.P+0");
   24343                                     assert(ios.width() == 0);
   24344                                 }
   24345                                 ios.width(25);
   24346                                 left(ios);
   24347                                 {
   24348                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24349                                     std::string ex(str, iter.base());
   24350                                     assert(ex == "-0X0.P+0*****************");
   24351                                     assert(ios.width() == 0);
   24352                                 }
   24353                                 ios.width(25);
   24354                                 right(ios);
   24355                                 {
   24356                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24357                                     std::string ex(str, iter.base());
   24358                                     assert(ex == "*****************-0X0.P+0");
   24359                                     assert(ios.width() == 0);
   24360                                 }
   24361                                 ios.width(25);
   24362                                 internal(ios);
   24363                                 {
   24364                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24365                                     std::string ex(str, iter.base());
   24366                                     assert(ex == "-*****************0X0.P+0");
   24367                                     assert(ios.width() == 0);
   24368                                 }
   24369                             }
   24370                             ios.imbue(lg);
   24371                             {
   24372                                 ios.width(0);
   24373                                 {
   24374                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24375                                     std::string ex(str, iter.base());
   24376                                     assert(ex == "-0X0;P+0");
   24377                                     assert(ios.width() == 0);
   24378                                 }
   24379                                 ios.width(25);
   24380                                 left(ios);
   24381                                 {
   24382                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24383                                     std::string ex(str, iter.base());
   24384                                     assert(ex == "-0X0;P+0*****************");
   24385                                     assert(ios.width() == 0);
   24386                                 }
   24387                                 ios.width(25);
   24388                                 right(ios);
   24389                                 {
   24390                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24391                                     std::string ex(str, iter.base());
   24392                                     assert(ex == "*****************-0X0;P+0");
   24393                                     assert(ios.width() == 0);
   24394                                 }
   24395                                 ios.width(25);
   24396                                 internal(ios);
   24397                                 {
   24398                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24399                                     std::string ex(str, iter.base());
   24400                                     assert(ex == "-*****************0X0;P+0");
   24401                                     assert(ios.width() == 0);
   24402                                 }
   24403                             }
   24404                         }
   24405                     }
   24406                 }
   24407             }
   24408             ios.precision(16);
   24409             {
   24410             }
   24411             ios.precision(60);
   24412             {
   24413             }
   24414         }
   24415     }
   24416 }
   24417 
   24418 void test12()
   24419 {
   24420     output_iterator<char*> iter;
   24421     std::locale lc = std::locale::classic();
   24422     std::locale lg(lc, new my_numpunct);
   24423 #ifdef __APPLE__
   24424 // This test is failing on FreeBSD, possibly due to different representations
   24425 // of the floating point numbers.
   24426     const my_facet f(1);
   24427     char str[200];
   24428     {
   24429         long double v = 1234567890.125;
   24430         std::ios ios(0);
   24431         hexfloat(ios);
   24432         // %a
   24433         {
   24434             ios.precision(0);
   24435             {
   24436                 nouppercase(ios);
   24437                 {
   24438                     noshowpos(ios);
   24439                     {
   24440                         noshowpoint(ios);
   24441                         {
   24442                                 ios.width(0);
   24443                             ios.imbue(lc);
   24444                             {
   24445                                 {
   24446                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24447                                     std::string ex(str, iter.base());
   24448                                     assert(ex == "0x9.32c05a44p+27");
   24449                                     assert(ios.width() == 0);
   24450                                 }
   24451                                 ios.width(25);
   24452                                 left(ios);
   24453                                 {
   24454                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24455                                     std::string ex(str, iter.base());
   24456                                     assert(ex == "0x9.32c05a44p+27*********");
   24457                                     assert(ios.width() == 0);
   24458                                 }
   24459                                 ios.width(25);
   24460                                 right(ios);
   24461                                 {
   24462                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24463                                     std::string ex(str, iter.base());
   24464                                     assert(ex == "*********0x9.32c05a44p+27");
   24465                                     assert(ios.width() == 0);
   24466                                 }
   24467                                 ios.width(25);
   24468                                 internal(ios);
   24469                                 {
   24470                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24471                                     std::string ex(str, iter.base());
   24472                                     assert(ex == "0x*********9.32c05a44p+27");
   24473                                     assert(ios.width() == 0);
   24474                                 }
   24475                             }
   24476                             ios.imbue(lg);
   24477                             {
   24478                                 ios.width(0);
   24479                                 {
   24480                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24481                                     std::string ex(str, iter.base());
   24482                                     assert(ex == "0x9;32c05a44p+27");
   24483                                     assert(ios.width() == 0);
   24484                                 }
   24485                                 ios.width(25);
   24486                                 left(ios);
   24487                                 {
   24488                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24489                                     std::string ex(str, iter.base());
   24490                                     assert(ex == "0x9;32c05a44p+27*********");
   24491                                     assert(ios.width() == 0);
   24492                                 }
   24493                                 ios.width(25);
   24494                                 right(ios);
   24495                                 {
   24496                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24497                                     std::string ex(str, iter.base());
   24498                                     assert(ex == "*********0x9;32c05a44p+27");
   24499                                     assert(ios.width() == 0);
   24500                                 }
   24501                                 ios.width(25);
   24502                                 internal(ios);
   24503                                 {
   24504                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24505                                     std::string ex(str, iter.base());
   24506                                     assert(ex == "0x*********9;32c05a44p+27");
   24507                                     assert(ios.width() == 0);
   24508                                 }
   24509                             }
   24510                         }
   24511                         showpoint(ios);
   24512                         {
   24513                             ios.imbue(lc);
   24514                             {
   24515                                 ios.width(0);
   24516                                 {
   24517                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24518                                     std::string ex(str, iter.base());
   24519                                     assert(ex == "0x9.32c05a44p+27");
   24520                                     assert(ios.width() == 0);
   24521                                 }
   24522                                 ios.width(25);
   24523                                 left(ios);
   24524                                 {
   24525                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24526                                     std::string ex(str, iter.base());
   24527                                     assert(ex == "0x9.32c05a44p+27*********");
   24528                                     assert(ios.width() == 0);
   24529                                 }
   24530                                 ios.width(25);
   24531                                 right(ios);
   24532                                 {
   24533                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24534                                     std::string ex(str, iter.base());
   24535                                     assert(ex == "*********0x9.32c05a44p+27");
   24536                                     assert(ios.width() == 0);
   24537                                 }
   24538                                 ios.width(25);
   24539                                 internal(ios);
   24540                                 {
   24541                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24542                                     std::string ex(str, iter.base());
   24543                                     assert(ex == "0x*********9.32c05a44p+27");
   24544                                     assert(ios.width() == 0);
   24545                                 }
   24546                             }
   24547                             ios.imbue(lg);
   24548                             {
   24549                                 ios.width(0);
   24550                                 {
   24551                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24552                                     std::string ex(str, iter.base());
   24553                                     assert(ex == "0x9;32c05a44p+27");
   24554                                     assert(ios.width() == 0);
   24555                                 }
   24556                                 ios.width(25);
   24557                                 left(ios);
   24558                                 {
   24559                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24560                                     std::string ex(str, iter.base());
   24561                                     assert(ex == "0x9;32c05a44p+27*********");
   24562                                     assert(ios.width() == 0);
   24563                                 }
   24564                                 ios.width(25);
   24565                                 right(ios);
   24566                                 {
   24567                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24568                                     std::string ex(str, iter.base());
   24569                                     assert(ex == "*********0x9;32c05a44p+27");
   24570                                     assert(ios.width() == 0);
   24571                                 }
   24572                                 ios.width(25);
   24573                                 internal(ios);
   24574                                 {
   24575                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24576                                     std::string ex(str, iter.base());
   24577                                     assert(ex == "0x*********9;32c05a44p+27");
   24578                                     assert(ios.width() == 0);
   24579                                 }
   24580                             }
   24581                         }
   24582                     }
   24583                     showpos(ios);
   24584                     {
   24585                         noshowpoint(ios);
   24586                         {
   24587                             ios.imbue(lc);
   24588                             {
   24589                                 ios.width(0);
   24590                                 {
   24591                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24592                                     std::string ex(str, iter.base());
   24593                                     assert(ex == "+0x9.32c05a44p+27");
   24594                                     assert(ios.width() == 0);
   24595                                 }
   24596                                 ios.width(25);
   24597                                 left(ios);
   24598                                 {
   24599                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24600                                     std::string ex(str, iter.base());
   24601                                     assert(ex == "+0x9.32c05a44p+27********");
   24602                                     assert(ios.width() == 0);
   24603                                 }
   24604                                 ios.width(25);
   24605                                 right(ios);
   24606                                 {
   24607                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24608                                     std::string ex(str, iter.base());
   24609                                     assert(ex == "********+0x9.32c05a44p+27");
   24610                                     assert(ios.width() == 0);
   24611                                 }
   24612                                 ios.width(25);
   24613                                 internal(ios);
   24614                                 {
   24615                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24616                                     std::string ex(str, iter.base());
   24617                                     assert(ex == "+********0x9.32c05a44p+27");
   24618                                     assert(ios.width() == 0);
   24619                                 }
   24620                             }
   24621                             ios.imbue(lg);
   24622                             {
   24623                                 ios.width(0);
   24624                                 {
   24625                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24626                                     std::string ex(str, iter.base());
   24627                                     assert(ex == "+0x9;32c05a44p+27");
   24628                                     assert(ios.width() == 0);
   24629                                 }
   24630                                 ios.width(25);
   24631                                 left(ios);
   24632                                 {
   24633                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24634                                     std::string ex(str, iter.base());
   24635                                     assert(ex == "+0x9;32c05a44p+27********");
   24636                                     assert(ios.width() == 0);
   24637                                 }
   24638                                 ios.width(25);
   24639                                 right(ios);
   24640                                 {
   24641                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24642                                     std::string ex(str, iter.base());
   24643                                     assert(ex == "********+0x9;32c05a44p+27");
   24644                                     assert(ios.width() == 0);
   24645                                 }
   24646                                 ios.width(25);
   24647                                 internal(ios);
   24648                                 {
   24649                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24650                                     std::string ex(str, iter.base());
   24651                                     assert(ex == "+********0x9;32c05a44p+27");
   24652                                     assert(ios.width() == 0);
   24653                                 }
   24654                             }
   24655                         }
   24656                         showpoint(ios);
   24657                         {
   24658                             ios.imbue(lc);
   24659                             {
   24660                                 ios.width(0);
   24661                                 {
   24662                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24663                                     std::string ex(str, iter.base());
   24664                                     assert(ex == "+0x9.32c05a44p+27");
   24665                                     assert(ios.width() == 0);
   24666                                 }
   24667                                 ios.width(25);
   24668                                 left(ios);
   24669                                 {
   24670                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24671                                     std::string ex(str, iter.base());
   24672                                     assert(ex == "+0x9.32c05a44p+27********");
   24673                                     assert(ios.width() == 0);
   24674                                 }
   24675                                 ios.width(25);
   24676                                 right(ios);
   24677                                 {
   24678                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24679                                     std::string ex(str, iter.base());
   24680                                     assert(ex == "********+0x9.32c05a44p+27");
   24681                                     assert(ios.width() == 0);
   24682                                 }
   24683                                 ios.width(25);
   24684                                 internal(ios);
   24685                                 {
   24686                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24687                                     std::string ex(str, iter.base());
   24688                                     assert(ex == "+********0x9.32c05a44p+27");
   24689                                     assert(ios.width() == 0);
   24690                                 }
   24691                             }
   24692                             ios.imbue(lg);
   24693                             {
   24694                                 ios.width(0);
   24695                                 {
   24696                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24697                                     std::string ex(str, iter.base());
   24698                                     assert(ex == "+0x9;32c05a44p+27");
   24699                                     assert(ios.width() == 0);
   24700                                 }
   24701                                 ios.width(25);
   24702                                 left(ios);
   24703                                 {
   24704                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24705                                     std::string ex(str, iter.base());
   24706                                     assert(ex == "+0x9;32c05a44p+27********");
   24707                                     assert(ios.width() == 0);
   24708                                 }
   24709                                 ios.width(25);
   24710                                 right(ios);
   24711                                 {
   24712                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24713                                     std::string ex(str, iter.base());
   24714                                     assert(ex == "********+0x9;32c05a44p+27");
   24715                                     assert(ios.width() == 0);
   24716                                 }
   24717                                 ios.width(25);
   24718                                 internal(ios);
   24719                                 {
   24720                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24721                                     std::string ex(str, iter.base());
   24722                                     assert(ex == "+********0x9;32c05a44p+27");
   24723                                     assert(ios.width() == 0);
   24724                                 }
   24725                             }
   24726                         }
   24727                     }
   24728                 }
   24729                 uppercase(ios);
   24730                 {
   24731                     noshowpos(ios);
   24732                     {
   24733                         noshowpoint(ios);
   24734                         {
   24735                             ios.imbue(lc);
   24736                             {
   24737                                 ios.width(0);
   24738                                 {
   24739                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24740                                     std::string ex(str, iter.base());
   24741                                     assert(ex == "0X9.32C05A44P+27");
   24742                                     assert(ios.width() == 0);
   24743                                 }
   24744                                 ios.width(25);
   24745                                 left(ios);
   24746                                 {
   24747                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24748                                     std::string ex(str, iter.base());
   24749                                     assert(ex == "0X9.32C05A44P+27*********");
   24750                                     assert(ios.width() == 0);
   24751                                 }
   24752                                 ios.width(25);
   24753                                 right(ios);
   24754                                 {
   24755                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24756                                     std::string ex(str, iter.base());
   24757                                     assert(ex == "*********0X9.32C05A44P+27");
   24758                                     assert(ios.width() == 0);
   24759                                 }
   24760                                 ios.width(25);
   24761                                 internal(ios);
   24762                                 {
   24763                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24764                                     std::string ex(str, iter.base());
   24765                                     assert(ex == "0X*********9.32C05A44P+27");
   24766                                     assert(ios.width() == 0);
   24767                                 }
   24768                             }
   24769                             ios.imbue(lg);
   24770                             {
   24771                                 ios.width(0);
   24772                                 {
   24773                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24774                                     std::string ex(str, iter.base());
   24775                                     assert(ex == "0X9;32C05A44P+27");
   24776                                     assert(ios.width() == 0);
   24777                                 }
   24778                                 ios.width(25);
   24779                                 left(ios);
   24780                                 {
   24781                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24782                                     std::string ex(str, iter.base());
   24783                                     assert(ex == "0X9;32C05A44P+27*********");
   24784                                     assert(ios.width() == 0);
   24785                                 }
   24786                                 ios.width(25);
   24787                                 right(ios);
   24788                                 {
   24789                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24790                                     std::string ex(str, iter.base());
   24791                                     assert(ex == "*********0X9;32C05A44P+27");
   24792                                     assert(ios.width() == 0);
   24793                                 }
   24794                                 ios.width(25);
   24795                                 internal(ios);
   24796                                 {
   24797                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24798                                     std::string ex(str, iter.base());
   24799                                     assert(ex == "0X*********9;32C05A44P+27");
   24800                                     assert(ios.width() == 0);
   24801                                 }
   24802                             }
   24803                         }
   24804                         showpoint(ios);
   24805                         {
   24806                             ios.imbue(lc);
   24807                             {
   24808                                 ios.width(0);
   24809                                 {
   24810                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24811                                     std::string ex(str, iter.base());
   24812                                     assert(ex == "0X9.32C05A44P+27");
   24813                                     assert(ios.width() == 0);
   24814                                 }
   24815                                 ios.width(25);
   24816                                 left(ios);
   24817                                 {
   24818                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24819                                     std::string ex(str, iter.base());
   24820                                     assert(ex == "0X9.32C05A44P+27*********");
   24821                                     assert(ios.width() == 0);
   24822                                 }
   24823                                 ios.width(25);
   24824                                 right(ios);
   24825                                 {
   24826                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24827                                     std::string ex(str, iter.base());
   24828                                     assert(ex == "*********0X9.32C05A44P+27");
   24829                                     assert(ios.width() == 0);
   24830                                 }
   24831                                 ios.width(25);
   24832                                 internal(ios);
   24833                                 {
   24834                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24835                                     std::string ex(str, iter.base());
   24836                                     assert(ex == "0X*********9.32C05A44P+27");
   24837                                     assert(ios.width() == 0);
   24838                                 }
   24839                             }
   24840                             ios.imbue(lg);
   24841                             {
   24842                                 ios.width(0);
   24843                                 {
   24844                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24845                                     std::string ex(str, iter.base());
   24846                                     assert(ex == "0X9;32C05A44P+27");
   24847                                     assert(ios.width() == 0);
   24848                                 }
   24849                                 ios.width(25);
   24850                                 left(ios);
   24851                                 {
   24852                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24853                                     std::string ex(str, iter.base());
   24854                                     assert(ex == "0X9;32C05A44P+27*********");
   24855                                     assert(ios.width() == 0);
   24856                                 }
   24857                                 ios.width(25);
   24858                                 right(ios);
   24859                                 {
   24860                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24861                                     std::string ex(str, iter.base());
   24862                                     assert(ex == "*********0X9;32C05A44P+27");
   24863                                     assert(ios.width() == 0);
   24864                                 }
   24865                                 ios.width(25);
   24866                                 internal(ios);
   24867                                 {
   24868                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24869                                     std::string ex(str, iter.base());
   24870                                     assert(ex == "0X*********9;32C05A44P+27");
   24871                                     assert(ios.width() == 0);
   24872                                 }
   24873                             }
   24874                         }
   24875                     }
   24876                     showpos(ios);
   24877                     {
   24878                         noshowpoint(ios);
   24879                         {
   24880                             ios.imbue(lc);
   24881                             {
   24882                                 ios.width(0);
   24883                                 {
   24884                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24885                                     std::string ex(str, iter.base());
   24886                                     assert(ex == "+0X9.32C05A44P+27");
   24887                                     assert(ios.width() == 0);
   24888                                 }
   24889                                 ios.width(25);
   24890                                 left(ios);
   24891                                 {
   24892                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24893                                     std::string ex(str, iter.base());
   24894                                     assert(ex == "+0X9.32C05A44P+27********");
   24895                                     assert(ios.width() == 0);
   24896                                 }
   24897                                 ios.width(25);
   24898                                 right(ios);
   24899                                 {
   24900                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24901                                     std::string ex(str, iter.base());
   24902                                     assert(ex == "********+0X9.32C05A44P+27");
   24903                                     assert(ios.width() == 0);
   24904                                 }
   24905                                 ios.width(25);
   24906                                 internal(ios);
   24907                                 {
   24908                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24909                                     std::string ex(str, iter.base());
   24910                                     assert(ex == "+********0X9.32C05A44P+27");
   24911                                     assert(ios.width() == 0);
   24912                                 }
   24913                             }
   24914                             ios.imbue(lg);
   24915                             {
   24916                                 ios.width(0);
   24917                                 {
   24918                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24919                                     std::string ex(str, iter.base());
   24920                                     assert(ex == "+0X9;32C05A44P+27");
   24921                                     assert(ios.width() == 0);
   24922                                 }
   24923                                 ios.width(25);
   24924                                 left(ios);
   24925                                 {
   24926                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24927                                     std::string ex(str, iter.base());
   24928                                     assert(ex == "+0X9;32C05A44P+27********");
   24929                                     assert(ios.width() == 0);
   24930                                 }
   24931                                 ios.width(25);
   24932                                 right(ios);
   24933                                 {
   24934                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24935                                     std::string ex(str, iter.base());
   24936                                     assert(ex == "********+0X9;32C05A44P+27");
   24937                                     assert(ios.width() == 0);
   24938                                 }
   24939                                 ios.width(25);
   24940                                 internal(ios);
   24941                                 {
   24942                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24943                                     std::string ex(str, iter.base());
   24944                                     assert(ex == "+********0X9;32C05A44P+27");
   24945                                     assert(ios.width() == 0);
   24946                                 }
   24947                             }
   24948                         }
   24949                         showpoint(ios);
   24950                         {
   24951                             ios.imbue(lc);
   24952                             {
   24953                                 ios.width(0);
   24954                                 {
   24955                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24956                                     std::string ex(str, iter.base());
   24957                                     assert(ex == "+0X9.32C05A44P+27");
   24958                                     assert(ios.width() == 0);
   24959                                 }
   24960                                 ios.width(25);
   24961                                 left(ios);
   24962                                 {
   24963                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24964                                     std::string ex(str, iter.base());
   24965                                     assert(ex == "+0X9.32C05A44P+27********");
   24966                                     assert(ios.width() == 0);
   24967                                 }
   24968                                 ios.width(25);
   24969                                 right(ios);
   24970                                 {
   24971                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24972                                     std::string ex(str, iter.base());
   24973                                     assert(ex == "********+0X9.32C05A44P+27");
   24974                                     assert(ios.width() == 0);
   24975                                 }
   24976                                 ios.width(25);
   24977                                 internal(ios);
   24978                                 {
   24979                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24980                                     std::string ex(str, iter.base());
   24981                                     assert(ex == "+********0X9.32C05A44P+27");
   24982                                     assert(ios.width() == 0);
   24983                                 }
   24984                             }
   24985                             ios.imbue(lg);
   24986                             {
   24987                                 ios.width(0);
   24988                                 {
   24989                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24990                                     std::string ex(str, iter.base());
   24991                                     assert(ex == "+0X9;32C05A44P+27");
   24992                                     assert(ios.width() == 0);
   24993                                 }
   24994                                 ios.width(25);
   24995                                 left(ios);
   24996                                 {
   24997                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   24998                                     std::string ex(str, iter.base());
   24999                                     assert(ex == "+0X9;32C05A44P+27********");
   25000                                     assert(ios.width() == 0);
   25001                                 }
   25002                                 ios.width(25);
   25003                                 right(ios);
   25004                                 {
   25005                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25006                                     std::string ex(str, iter.base());
   25007                                     assert(ex == "********+0X9;32C05A44P+27");
   25008                                     assert(ios.width() == 0);
   25009                                 }
   25010                                 ios.width(25);
   25011                                 internal(ios);
   25012                                 {
   25013                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25014                                     std::string ex(str, iter.base());
   25015                                     assert(ex == "+********0X9;32C05A44P+27");
   25016                                     assert(ios.width() == 0);
   25017                                 }
   25018                             }
   25019                         }
   25020                     }
   25021                 }
   25022             }
   25023             ios.precision(1);
   25024             {
   25025                 nouppercase(ios);
   25026                 {
   25027                     noshowpos(ios);
   25028                     {
   25029                         noshowpoint(ios);
   25030                         {
   25031                             ios.imbue(lc);
   25032                             {
   25033                                 ios.width(0);
   25034                                 {
   25035                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25036                                     std::string ex(str, iter.base());
   25037                                     assert(ex == "0x9.32c05a44p+27");
   25038                                     assert(ios.width() == 0);
   25039                                 }
   25040                                 ios.width(25);
   25041                                 left(ios);
   25042                                 {
   25043                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25044                                     std::string ex(str, iter.base());
   25045                                     assert(ex == "0x9.32c05a44p+27*********");
   25046                                     assert(ios.width() == 0);
   25047                                 }
   25048                                 ios.width(25);
   25049                                 right(ios);
   25050                                 {
   25051                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25052                                     std::string ex(str, iter.base());
   25053                                     assert(ex == "*********0x9.32c05a44p+27");
   25054                                     assert(ios.width() == 0);
   25055                                 }
   25056                                 ios.width(25);
   25057                                 internal(ios);
   25058                                 {
   25059                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25060                                     std::string ex(str, iter.base());
   25061                                     assert(ex == "0x*********9.32c05a44p+27");
   25062                                     assert(ios.width() == 0);
   25063                                 }
   25064                             }
   25065                             ios.imbue(lg);
   25066                             {
   25067                                 ios.width(0);
   25068                                 {
   25069                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25070                                     std::string ex(str, iter.base());
   25071                                     assert(ex == "0x9;32c05a44p+27");
   25072                                     assert(ios.width() == 0);
   25073                                 }
   25074                                 ios.width(25);
   25075                                 left(ios);
   25076                                 {
   25077                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25078                                     std::string ex(str, iter.base());
   25079                                     assert(ex == "0x9;32c05a44p+27*********");
   25080                                     assert(ios.width() == 0);
   25081                                 }
   25082                                 ios.width(25);
   25083                                 right(ios);
   25084                                 {
   25085                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25086                                     std::string ex(str, iter.base());
   25087                                     assert(ex == "*********0x9;32c05a44p+27");
   25088                                     assert(ios.width() == 0);
   25089                                 }
   25090                                 ios.width(25);
   25091                                 internal(ios);
   25092                                 {
   25093                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25094                                     std::string ex(str, iter.base());
   25095                                     assert(ex == "0x*********9;32c05a44p+27");
   25096                                     assert(ios.width() == 0);
   25097                                 }
   25098                             }
   25099                         }
   25100                         showpoint(ios);
   25101                         {
   25102                             ios.imbue(lc);
   25103                             {
   25104                                 ios.width(0);
   25105                                 {
   25106                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25107                                     std::string ex(str, iter.base());
   25108                                     assert(ex == "0x9.32c05a44p+27");
   25109                                     assert(ios.width() == 0);
   25110                                 }
   25111                                 ios.width(25);
   25112                                 left(ios);
   25113                                 {
   25114                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25115                                     std::string ex(str, iter.base());
   25116                                     assert(ex == "0x9.32c05a44p+27*********");
   25117                                     assert(ios.width() == 0);
   25118                                 }
   25119                                 ios.width(25);
   25120                                 right(ios);
   25121                                 {
   25122                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25123                                     std::string ex(str, iter.base());
   25124                                     assert(ex == "*********0x9.32c05a44p+27");
   25125                                     assert(ios.width() == 0);
   25126                                 }
   25127                                 ios.width(25);
   25128                                 internal(ios);
   25129                                 {
   25130                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25131                                     std::string ex(str, iter.base());
   25132                                     assert(ex == "0x*********9.32c05a44p+27");
   25133                                     assert(ios.width() == 0);
   25134                                 }
   25135                             }
   25136                             ios.imbue(lg);
   25137                             {
   25138                                 ios.width(0);
   25139                                 {
   25140                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25141                                     std::string ex(str, iter.base());
   25142                                     assert(ex == "0x9;32c05a44p+27");
   25143                                     assert(ios.width() == 0);
   25144                                 }
   25145                                 ios.width(25);
   25146                                 left(ios);
   25147                                 {
   25148                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25149                                     std::string ex(str, iter.base());
   25150                                     assert(ex == "0x9;32c05a44p+27*********");
   25151                                     assert(ios.width() == 0);
   25152                                 }
   25153                                 ios.width(25);
   25154                                 right(ios);
   25155                                 {
   25156                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25157                                     std::string ex(str, iter.base());
   25158                                     assert(ex == "*********0x9;32c05a44p+27");
   25159                                     assert(ios.width() == 0);
   25160                                 }
   25161                                 ios.width(25);
   25162                                 internal(ios);
   25163                                 {
   25164                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25165                                     std::string ex(str, iter.base());
   25166                                     assert(ex == "0x*********9;32c05a44p+27");
   25167                                     assert(ios.width() == 0);
   25168                                 }
   25169                             }
   25170                         }
   25171                     }
   25172                     showpos(ios);
   25173                     {
   25174                         noshowpoint(ios);
   25175                         {
   25176                             ios.imbue(lc);
   25177                             {
   25178                                 ios.width(0);
   25179                                 {
   25180                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25181                                     std::string ex(str, iter.base());
   25182                                     assert(ex == "+0x9.32c05a44p+27");
   25183                                     assert(ios.width() == 0);
   25184                                 }
   25185                                 ios.width(25);
   25186                                 left(ios);
   25187                                 {
   25188                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25189                                     std::string ex(str, iter.base());
   25190                                     assert(ex == "+0x9.32c05a44p+27********");
   25191                                     assert(ios.width() == 0);
   25192                                 }
   25193                                 ios.width(25);
   25194                                 right(ios);
   25195                                 {
   25196                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25197                                     std::string ex(str, iter.base());
   25198                                     assert(ex == "********+0x9.32c05a44p+27");
   25199                                     assert(ios.width() == 0);
   25200                                 }
   25201                                 ios.width(25);
   25202                                 internal(ios);
   25203                                 {
   25204                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25205                                     std::string ex(str, iter.base());
   25206                                     assert(ex == "+********0x9.32c05a44p+27");
   25207                                     assert(ios.width() == 0);
   25208                                 }
   25209                             }
   25210                             ios.imbue(lg);
   25211                             {
   25212                                 ios.width(0);
   25213                                 {
   25214                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25215                                     std::string ex(str, iter.base());
   25216                                     assert(ex == "+0x9;32c05a44p+27");
   25217                                     assert(ios.width() == 0);
   25218                                 }
   25219                                 ios.width(25);
   25220                                 left(ios);
   25221                                 {
   25222                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25223                                     std::string ex(str, iter.base());
   25224                                     assert(ex == "+0x9;32c05a44p+27********");
   25225                                     assert(ios.width() == 0);
   25226                                 }
   25227                                 ios.width(25);
   25228                                 right(ios);
   25229                                 {
   25230                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25231                                     std::string ex(str, iter.base());
   25232                                     assert(ex == "********+0x9;32c05a44p+27");
   25233                                     assert(ios.width() == 0);
   25234                                 }
   25235                                 ios.width(25);
   25236                                 internal(ios);
   25237                                 {
   25238                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25239                                     std::string ex(str, iter.base());
   25240                                     assert(ex == "+********0x9;32c05a44p+27");
   25241                                     assert(ios.width() == 0);
   25242                                 }
   25243                             }
   25244                         }
   25245                         showpoint(ios);
   25246                         {
   25247                             ios.imbue(lc);
   25248                             {
   25249                                 ios.width(0);
   25250                                 {
   25251                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25252                                     std::string ex(str, iter.base());
   25253                                     assert(ex == "+0x9.32c05a44p+27");
   25254                                     assert(ios.width() == 0);
   25255                                 }
   25256                                 ios.width(25);
   25257                                 left(ios);
   25258                                 {
   25259                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25260                                     std::string ex(str, iter.base());
   25261                                     assert(ex == "+0x9.32c05a44p+27********");
   25262                                     assert(ios.width() == 0);
   25263                                 }
   25264                                 ios.width(25);
   25265                                 right(ios);
   25266                                 {
   25267                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25268                                     std::string ex(str, iter.base());
   25269                                     assert(ex == "********+0x9.32c05a44p+27");
   25270                                     assert(ios.width() == 0);
   25271                                 }
   25272                                 ios.width(25);
   25273                                 internal(ios);
   25274                                 {
   25275                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25276                                     std::string ex(str, iter.base());
   25277                                     assert(ex == "+********0x9.32c05a44p+27");
   25278                                     assert(ios.width() == 0);
   25279                                 }
   25280                             }
   25281                             ios.imbue(lg);
   25282                             {
   25283                                 ios.width(0);
   25284                                 {
   25285                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25286                                     std::string ex(str, iter.base());
   25287                                     assert(ex == "+0x9;32c05a44p+27");
   25288                                     assert(ios.width() == 0);
   25289                                 }
   25290                                 ios.width(25);
   25291                                 left(ios);
   25292                                 {
   25293                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25294                                     std::string ex(str, iter.base());
   25295                                     assert(ex == "+0x9;32c05a44p+27********");
   25296                                     assert(ios.width() == 0);
   25297                                 }
   25298                                 ios.width(25);
   25299                                 right(ios);
   25300                                 {
   25301                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25302                                     std::string ex(str, iter.base());
   25303                                     assert(ex == "********+0x9;32c05a44p+27");
   25304                                     assert(ios.width() == 0);
   25305                                 }
   25306                                 ios.width(25);
   25307                                 internal(ios);
   25308                                 {
   25309                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25310                                     std::string ex(str, iter.base());
   25311                                     assert(ex == "+********0x9;32c05a44p+27");
   25312                                     assert(ios.width() == 0);
   25313                                 }
   25314                             }
   25315                         }
   25316                     }
   25317                 }
   25318                 uppercase(ios);
   25319                 {
   25320                     noshowpos(ios);
   25321                     {
   25322                         noshowpoint(ios);
   25323                         {
   25324                             ios.imbue(lc);
   25325                             {
   25326                                 ios.width(0);
   25327                                 {
   25328                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25329                                     std::string ex(str, iter.base());
   25330                                     assert(ex == "0X9.32C05A44P+27");
   25331                                     assert(ios.width() == 0);
   25332                                 }
   25333                                 ios.width(25);
   25334                                 left(ios);
   25335                                 {
   25336                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25337                                     std::string ex(str, iter.base());
   25338                                     assert(ex == "0X9.32C05A44P+27*********");
   25339                                     assert(ios.width() == 0);
   25340                                 }
   25341                                 ios.width(25);
   25342                                 right(ios);
   25343                                 {
   25344                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25345                                     std::string ex(str, iter.base());
   25346                                     assert(ex == "*********0X9.32C05A44P+27");
   25347                                     assert(ios.width() == 0);
   25348                                 }
   25349                                 ios.width(25);
   25350                                 internal(ios);
   25351                                 {
   25352                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25353                                     std::string ex(str, iter.base());
   25354                                     assert(ex == "0X*********9.32C05A44P+27");
   25355                                     assert(ios.width() == 0);
   25356                                 }
   25357                             }
   25358                             ios.imbue(lg);
   25359                             {
   25360                                 ios.width(0);
   25361                                 {
   25362                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25363                                     std::string ex(str, iter.base());
   25364                                     assert(ex == "0X9;32C05A44P+27");
   25365                                     assert(ios.width() == 0);
   25366                                 }
   25367                                 ios.width(25);
   25368                                 left(ios);
   25369                                 {
   25370                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25371                                     std::string ex(str, iter.base());
   25372                                     assert(ex == "0X9;32C05A44P+27*********");
   25373                                     assert(ios.width() == 0);
   25374                                 }
   25375                                 ios.width(25);
   25376                                 right(ios);
   25377                                 {
   25378                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25379                                     std::string ex(str, iter.base());
   25380                                     assert(ex == "*********0X9;32C05A44P+27");
   25381                                     assert(ios.width() == 0);
   25382                                 }
   25383                                 ios.width(25);
   25384                                 internal(ios);
   25385                                 {
   25386                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25387                                     std::string ex(str, iter.base());
   25388                                     assert(ex == "0X*********9;32C05A44P+27");
   25389                                     assert(ios.width() == 0);
   25390                                 }
   25391                             }
   25392                         }
   25393                         showpoint(ios);
   25394                         {
   25395                             ios.imbue(lc);
   25396                             {
   25397                                 ios.width(0);
   25398                                 {
   25399                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25400                                     std::string ex(str, iter.base());
   25401                                     assert(ex == "0X9.32C05A44P+27");
   25402                                     assert(ios.width() == 0);
   25403                                 }
   25404                                 ios.width(25);
   25405                                 left(ios);
   25406                                 {
   25407                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25408                                     std::string ex(str, iter.base());
   25409                                     assert(ex == "0X9.32C05A44P+27*********");
   25410                                     assert(ios.width() == 0);
   25411                                 }
   25412                                 ios.width(25);
   25413                                 right(ios);
   25414                                 {
   25415                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25416                                     std::string ex(str, iter.base());
   25417                                     assert(ex == "*********0X9.32C05A44P+27");
   25418                                     assert(ios.width() == 0);
   25419                                 }
   25420                                 ios.width(25);
   25421                                 internal(ios);
   25422                                 {
   25423                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25424                                     std::string ex(str, iter.base());
   25425                                     assert(ex == "0X*********9.32C05A44P+27");
   25426                                     assert(ios.width() == 0);
   25427                                 }
   25428                             }
   25429                             ios.imbue(lg);
   25430                             {
   25431                                 ios.width(0);
   25432                                 {
   25433                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25434                                     std::string ex(str, iter.base());
   25435                                     assert(ex == "0X9;32C05A44P+27");
   25436                                     assert(ios.width() == 0);
   25437                                 }
   25438                                 ios.width(25);
   25439                                 left(ios);
   25440                                 {
   25441                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25442                                     std::string ex(str, iter.base());
   25443                                     assert(ex == "0X9;32C05A44P+27*********");
   25444                                     assert(ios.width() == 0);
   25445                                 }
   25446                                 ios.width(25);
   25447                                 right(ios);
   25448                                 {
   25449                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25450                                     std::string ex(str, iter.base());
   25451                                     assert(ex == "*********0X9;32C05A44P+27");
   25452                                     assert(ios.width() == 0);
   25453                                 }
   25454                                 ios.width(25);
   25455                                 internal(ios);
   25456                                 {
   25457                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25458                                     std::string ex(str, iter.base());
   25459                                     assert(ex == "0X*********9;32C05A44P+27");
   25460                                     assert(ios.width() == 0);
   25461                                 }
   25462                             }
   25463                         }
   25464                     }
   25465                     showpos(ios);
   25466                     {
   25467                         noshowpoint(ios);
   25468                         {
   25469                             ios.imbue(lc);
   25470                             {
   25471                                 ios.width(0);
   25472                                 {
   25473                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25474                                     std::string ex(str, iter.base());
   25475                                     assert(ex == "+0X9.32C05A44P+27");
   25476                                     assert(ios.width() == 0);
   25477                                 }
   25478                                 ios.width(25);
   25479                                 left(ios);
   25480                                 {
   25481                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25482                                     std::string ex(str, iter.base());
   25483                                     assert(ex == "+0X9.32C05A44P+27********");
   25484                                     assert(ios.width() == 0);
   25485                                 }
   25486                                 ios.width(25);
   25487                                 right(ios);
   25488                                 {
   25489                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25490                                     std::string ex(str, iter.base());
   25491                                     assert(ex == "********+0X9.32C05A44P+27");
   25492                                     assert(ios.width() == 0);
   25493                                 }
   25494                                 ios.width(25);
   25495                                 internal(ios);
   25496                                 {
   25497                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25498                                     std::string ex(str, iter.base());
   25499                                     assert(ex == "+********0X9.32C05A44P+27");
   25500                                     assert(ios.width() == 0);
   25501                                 }
   25502                             }
   25503                             ios.imbue(lg);
   25504                             {
   25505                                 ios.width(0);
   25506                                 {
   25507                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25508                                     std::string ex(str, iter.base());
   25509                                     assert(ex == "+0X9;32C05A44P+27");
   25510                                     assert(ios.width() == 0);
   25511                                 }
   25512                                 ios.width(25);
   25513                                 left(ios);
   25514                                 {
   25515                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25516                                     std::string ex(str, iter.base());
   25517                                     assert(ex == "+0X9;32C05A44P+27********");
   25518                                     assert(ios.width() == 0);
   25519                                 }
   25520                                 ios.width(25);
   25521                                 right(ios);
   25522                                 {
   25523                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25524                                     std::string ex(str, iter.base());
   25525                                     assert(ex == "********+0X9;32C05A44P+27");
   25526                                     assert(ios.width() == 0);
   25527                                 }
   25528                                 ios.width(25);
   25529                                 internal(ios);
   25530                                 {
   25531                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25532                                     std::string ex(str, iter.base());
   25533                                     assert(ex == "+********0X9;32C05A44P+27");
   25534                                     assert(ios.width() == 0);
   25535                                 }
   25536                             }
   25537                         }
   25538                         showpoint(ios);
   25539                         {
   25540                             ios.imbue(lc);
   25541                             {
   25542                                 ios.width(0);
   25543                                 {
   25544                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25545                                     std::string ex(str, iter.base());
   25546                                     assert(ex == "+0X9.32C05A44P+27");
   25547                                     assert(ios.width() == 0);
   25548                                 }
   25549                                 ios.width(25);
   25550                                 left(ios);
   25551                                 {
   25552                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25553                                     std::string ex(str, iter.base());
   25554                                     assert(ex == "+0X9.32C05A44P+27********");
   25555                                     assert(ios.width() == 0);
   25556                                 }
   25557                                 ios.width(25);
   25558                                 right(ios);
   25559                                 {
   25560                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25561                                     std::string ex(str, iter.base());
   25562                                     assert(ex == "********+0X9.32C05A44P+27");
   25563                                     assert(ios.width() == 0);
   25564                                 }
   25565                                 ios.width(25);
   25566                                 internal(ios);
   25567                                 {
   25568                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25569                                     std::string ex(str, iter.base());
   25570                                     assert(ex == "+********0X9.32C05A44P+27");
   25571                                     assert(ios.width() == 0);
   25572                                 }
   25573                             }
   25574                             ios.imbue(lg);
   25575                             {
   25576                                 ios.width(0);
   25577                                 {
   25578                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25579                                     std::string ex(str, iter.base());
   25580                                     assert(ex == "+0X9;32C05A44P+27");
   25581                                     assert(ios.width() == 0);
   25582                                 }
   25583                                 ios.width(25);
   25584                                 left(ios);
   25585                                 {
   25586                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25587                                     std::string ex(str, iter.base());
   25588                                     assert(ex == "+0X9;32C05A44P+27********");
   25589                                     assert(ios.width() == 0);
   25590                                 }
   25591                                 ios.width(25);
   25592                                 right(ios);
   25593                                 {
   25594                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25595                                     std::string ex(str, iter.base());
   25596                                     assert(ex == "********+0X9;32C05A44P+27");
   25597                                     assert(ios.width() == 0);
   25598                                 }
   25599                                 ios.width(25);
   25600                                 internal(ios);
   25601                                 {
   25602                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25603                                     std::string ex(str, iter.base());
   25604                                     assert(ex == "+********0X9;32C05A44P+27");
   25605                                     assert(ios.width() == 0);
   25606                                 }
   25607                             }
   25608                         }
   25609                     }
   25610                 }
   25611             }
   25612             ios.precision(6);
   25613             {
   25614             }
   25615             ios.precision(16);
   25616             {
   25617             }
   25618             ios.precision(60);
   25619             {
   25620                 nouppercase(ios);
   25621                 {
   25622                     noshowpos(ios);
   25623                     {
   25624                         noshowpoint(ios);
   25625                         {
   25626                             ios.imbue(lc);
   25627                             {
   25628                                 ios.width(0);
   25629                                 {
   25630                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25631                                     std::string ex(str, iter.base());
   25632                                     assert(ex == "0x9.32c05a44p+27");
   25633                                     assert(ios.width() == 0);
   25634                                 }
   25635                                 ios.width(25);
   25636                                 left(ios);
   25637                                 {
   25638                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25639                                     std::string ex(str, iter.base());
   25640                                     assert(ex == "0x9.32c05a44p+27*********");
   25641                                     assert(ios.width() == 0);
   25642                                 }
   25643                                 ios.width(25);
   25644                                 right(ios);
   25645                                 {
   25646                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25647                                     std::string ex(str, iter.base());
   25648                                     assert(ex == "*********0x9.32c05a44p+27");
   25649                                     assert(ios.width() == 0);
   25650                                 }
   25651                                 ios.width(25);
   25652                                 internal(ios);
   25653                                 {
   25654                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25655                                     std::string ex(str, iter.base());
   25656                                     assert(ex == "0x*********9.32c05a44p+27");
   25657                                     assert(ios.width() == 0);
   25658                                 }
   25659                             }
   25660                             ios.imbue(lg);
   25661                             {
   25662                                 ios.width(0);
   25663                                 {
   25664                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25665                                     std::string ex(str, iter.base());
   25666                                     assert(ex == "0x9;32c05a44p+27");
   25667                                     assert(ios.width() == 0);
   25668                                 }
   25669                                 ios.width(25);
   25670                                 left(ios);
   25671                                 {
   25672                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25673                                     std::string ex(str, iter.base());
   25674                                     assert(ex == "0x9;32c05a44p+27*********");
   25675                                     assert(ios.width() == 0);
   25676                                 }
   25677                                 ios.width(25);
   25678                                 right(ios);
   25679                                 {
   25680                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25681                                     std::string ex(str, iter.base());
   25682                                     assert(ex == "*********0x9;32c05a44p+27");
   25683                                     assert(ios.width() == 0);
   25684                                 }
   25685                                 ios.width(25);
   25686                                 internal(ios);
   25687                                 {
   25688                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25689                                     std::string ex(str, iter.base());
   25690                                     assert(ex == "0x*********9;32c05a44p+27");
   25691                                     assert(ios.width() == 0);
   25692                                 }
   25693                             }
   25694                         }
   25695                         showpoint(ios);
   25696                         {
   25697                             ios.imbue(lc);
   25698                             {
   25699                                 ios.width(0);
   25700                                 {
   25701                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25702                                     std::string ex(str, iter.base());
   25703                                     assert(ex == "0x9.32c05a44p+27");
   25704                                     assert(ios.width() == 0);
   25705                                 }
   25706                                 ios.width(25);
   25707                                 left(ios);
   25708                                 {
   25709                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25710                                     std::string ex(str, iter.base());
   25711                                     assert(ex == "0x9.32c05a44p+27*********");
   25712                                     assert(ios.width() == 0);
   25713                                 }
   25714                                 ios.width(25);
   25715                                 right(ios);
   25716                                 {
   25717                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25718                                     std::string ex(str, iter.base());
   25719                                     assert(ex == "*********0x9.32c05a44p+27");
   25720                                     assert(ios.width() == 0);
   25721                                 }
   25722                                 ios.width(25);
   25723                                 internal(ios);
   25724                                 {
   25725                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25726                                     std::string ex(str, iter.base());
   25727                                     assert(ex == "0x*********9.32c05a44p+27");
   25728                                     assert(ios.width() == 0);
   25729                                 }
   25730                             }
   25731                             ios.imbue(lg);
   25732                             {
   25733                                 ios.width(0);
   25734                                 {
   25735                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25736                                     std::string ex(str, iter.base());
   25737                                     assert(ex == "0x9;32c05a44p+27");
   25738                                     assert(ios.width() == 0);
   25739                                 }
   25740                                 ios.width(25);
   25741                                 left(ios);
   25742                                 {
   25743                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25744                                     std::string ex(str, iter.base());
   25745                                     assert(ex == "0x9;32c05a44p+27*********");
   25746                                     assert(ios.width() == 0);
   25747                                 }
   25748                                 ios.width(25);
   25749                                 right(ios);
   25750                                 {
   25751                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25752                                     std::string ex(str, iter.base());
   25753                                     assert(ex == "*********0x9;32c05a44p+27");
   25754                                     assert(ios.width() == 0);
   25755                                 }
   25756                                 ios.width(25);
   25757                                 internal(ios);
   25758                                 {
   25759                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25760                                     std::string ex(str, iter.base());
   25761                                     assert(ex == "0x*********9;32c05a44p+27");
   25762                                     assert(ios.width() == 0);
   25763                                 }
   25764                             }
   25765                         }
   25766                     }
   25767                     showpos(ios);
   25768                     {
   25769                         noshowpoint(ios);
   25770                         {
   25771                             ios.imbue(lc);
   25772                             {
   25773                                 ios.width(0);
   25774                                 {
   25775                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25776                                     std::string ex(str, iter.base());
   25777                                     assert(ex == "+0x9.32c05a44p+27");
   25778                                     assert(ios.width() == 0);
   25779                                 }
   25780                                 ios.width(25);
   25781                                 left(ios);
   25782                                 {
   25783                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25784                                     std::string ex(str, iter.base());
   25785                                     assert(ex == "+0x9.32c05a44p+27********");
   25786                                     assert(ios.width() == 0);
   25787                                 }
   25788                                 ios.width(25);
   25789                                 right(ios);
   25790                                 {
   25791                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25792                                     std::string ex(str, iter.base());
   25793                                     assert(ex == "********+0x9.32c05a44p+27");
   25794                                     assert(ios.width() == 0);
   25795                                 }
   25796                                 ios.width(25);
   25797                                 internal(ios);
   25798                                 {
   25799                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25800                                     std::string ex(str, iter.base());
   25801                                     assert(ex == "+********0x9.32c05a44p+27");
   25802                                     assert(ios.width() == 0);
   25803                                 }
   25804                             }
   25805                             ios.imbue(lg);
   25806                             {
   25807                                 ios.width(0);
   25808                                 {
   25809                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25810                                     std::string ex(str, iter.base());
   25811                                     assert(ex == "+0x9;32c05a44p+27");
   25812                                     assert(ios.width() == 0);
   25813                                 }
   25814                                 ios.width(25);
   25815                                 left(ios);
   25816                                 {
   25817                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25818                                     std::string ex(str, iter.base());
   25819                                     assert(ex == "+0x9;32c05a44p+27********");
   25820                                     assert(ios.width() == 0);
   25821                                 }
   25822                                 ios.width(25);
   25823                                 right(ios);
   25824                                 {
   25825                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25826                                     std::string ex(str, iter.base());
   25827                                     assert(ex == "********+0x9;32c05a44p+27");
   25828                                     assert(ios.width() == 0);
   25829                                 }
   25830                                 ios.width(25);
   25831                                 internal(ios);
   25832                                 {
   25833                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25834                                     std::string ex(str, iter.base());
   25835                                     assert(ex == "+********0x9;32c05a44p+27");
   25836                                     assert(ios.width() == 0);
   25837                                 }
   25838                             }
   25839                         }
   25840                         showpoint(ios);
   25841                         {
   25842                             ios.imbue(lc);
   25843                             {
   25844                                 ios.width(0);
   25845                                 {
   25846                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25847                                     std::string ex(str, iter.base());
   25848                                     assert(ex == "+0x9.32c05a44p+27");
   25849                                     assert(ios.width() == 0);
   25850                                 }
   25851                                 ios.width(25);
   25852                                 left(ios);
   25853                                 {
   25854                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25855                                     std::string ex(str, iter.base());
   25856                                     assert(ex == "+0x9.32c05a44p+27********");
   25857                                     assert(ios.width() == 0);
   25858                                 }
   25859                                 ios.width(25);
   25860                                 right(ios);
   25861                                 {
   25862                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25863                                     std::string ex(str, iter.base());
   25864                                     assert(ex == "********+0x9.32c05a44p+27");
   25865                                     assert(ios.width() == 0);
   25866                                 }
   25867                                 ios.width(25);
   25868                                 internal(ios);
   25869                                 {
   25870                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25871                                     std::string ex(str, iter.base());
   25872                                     assert(ex == "+********0x9.32c05a44p+27");
   25873                                     assert(ios.width() == 0);
   25874                                 }
   25875                             }
   25876                             ios.imbue(lg);
   25877                             {
   25878                                 ios.width(0);
   25879                                 {
   25880                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25881                                     std::string ex(str, iter.base());
   25882                                     assert(ex == "+0x9;32c05a44p+27");
   25883                                     assert(ios.width() == 0);
   25884                                 }
   25885                                 ios.width(25);
   25886                                 left(ios);
   25887                                 {
   25888                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25889                                     std::string ex(str, iter.base());
   25890                                     assert(ex == "+0x9;32c05a44p+27********");
   25891                                     assert(ios.width() == 0);
   25892                                 }
   25893                                 ios.width(25);
   25894                                 right(ios);
   25895                                 {
   25896                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25897                                     std::string ex(str, iter.base());
   25898                                     assert(ex == "********+0x9;32c05a44p+27");
   25899                                     assert(ios.width() == 0);
   25900                                 }
   25901                                 ios.width(25);
   25902                                 internal(ios);
   25903                                 {
   25904                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25905                                     std::string ex(str, iter.base());
   25906                                     assert(ex == "+********0x9;32c05a44p+27");
   25907                                     assert(ios.width() == 0);
   25908                                 }
   25909                             }
   25910                         }
   25911                     }
   25912                 }
   25913                 uppercase(ios);
   25914                 {
   25915                     noshowpos(ios);
   25916                     {
   25917                         noshowpoint(ios);
   25918                         {
   25919                             ios.imbue(lc);
   25920                             {
   25921                                 ios.width(0);
   25922                                 {
   25923                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25924                                     std::string ex(str, iter.base());
   25925                                     assert(ex == "0X9.32C05A44P+27");
   25926                                     assert(ios.width() == 0);
   25927                                 }
   25928                                 ios.width(25);
   25929                                 left(ios);
   25930                                 {
   25931                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25932                                     std::string ex(str, iter.base());
   25933                                     assert(ex == "0X9.32C05A44P+27*********");
   25934                                     assert(ios.width() == 0);
   25935                                 }
   25936                                 ios.width(25);
   25937                                 right(ios);
   25938                                 {
   25939                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25940                                     std::string ex(str, iter.base());
   25941                                     assert(ex == "*********0X9.32C05A44P+27");
   25942                                     assert(ios.width() == 0);
   25943                                 }
   25944                                 ios.width(25);
   25945                                 internal(ios);
   25946                                 {
   25947                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25948                                     std::string ex(str, iter.base());
   25949                                     assert(ex == "0X*********9.32C05A44P+27");
   25950                                     assert(ios.width() == 0);
   25951                                 }
   25952                             }
   25953                             ios.imbue(lg);
   25954                             {
   25955                                 ios.width(0);
   25956                                 {
   25957                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25958                                     std::string ex(str, iter.base());
   25959                                     assert(ex == "0X9;32C05A44P+27");
   25960                                     assert(ios.width() == 0);
   25961                                 }
   25962                                 ios.width(25);
   25963                                 left(ios);
   25964                                 {
   25965                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25966                                     std::string ex(str, iter.base());
   25967                                     assert(ex == "0X9;32C05A44P+27*********");
   25968                                     assert(ios.width() == 0);
   25969                                 }
   25970                                 ios.width(25);
   25971                                 right(ios);
   25972                                 {
   25973                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25974                                     std::string ex(str, iter.base());
   25975                                     assert(ex == "*********0X9;32C05A44P+27");
   25976                                     assert(ios.width() == 0);
   25977                                 }
   25978                                 ios.width(25);
   25979                                 internal(ios);
   25980                                 {
   25981                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25982                                     std::string ex(str, iter.base());
   25983                                     assert(ex == "0X*********9;32C05A44P+27");
   25984                                     assert(ios.width() == 0);
   25985                                 }
   25986                             }
   25987                         }
   25988                         showpoint(ios);
   25989                         {
   25990                             ios.imbue(lc);
   25991                             {
   25992                                 ios.width(0);
   25993                                 {
   25994                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   25995                                     std::string ex(str, iter.base());
   25996                                     assert(ex == "0X9.32C05A44P+27");
   25997                                     assert(ios.width() == 0);
   25998                                 }
   25999                                 ios.width(25);
   26000                                 left(ios);
   26001                                 {
   26002                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26003                                     std::string ex(str, iter.base());
   26004                                     assert(ex == "0X9.32C05A44P+27*********");
   26005                                     assert(ios.width() == 0);
   26006                                 }
   26007                                 ios.width(25);
   26008                                 right(ios);
   26009                                 {
   26010                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26011                                     std::string ex(str, iter.base());
   26012                                     assert(ex == "*********0X9.32C05A44P+27");
   26013                                     assert(ios.width() == 0);
   26014                                 }
   26015                                 ios.width(25);
   26016                                 internal(ios);
   26017                                 {
   26018                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26019                                     std::string ex(str, iter.base());
   26020                                     assert(ex == "0X*********9.32C05A44P+27");
   26021                                     assert(ios.width() == 0);
   26022                                 }
   26023                             }
   26024                             ios.imbue(lg);
   26025                             {
   26026                                 ios.width(0);
   26027                                 {
   26028                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26029                                     std::string ex(str, iter.base());
   26030                                     assert(ex == "0X9;32C05A44P+27");
   26031                                     assert(ios.width() == 0);
   26032                                 }
   26033                                 ios.width(25);
   26034                                 left(ios);
   26035                                 {
   26036                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26037                                     std::string ex(str, iter.base());
   26038                                     assert(ex == "0X9;32C05A44P+27*********");
   26039                                     assert(ios.width() == 0);
   26040                                 }
   26041                                 ios.width(25);
   26042                                 right(ios);
   26043                                 {
   26044                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26045                                     std::string ex(str, iter.base());
   26046                                     assert(ex == "*********0X9;32C05A44P+27");
   26047                                     assert(ios.width() == 0);
   26048                                 }
   26049                                 ios.width(25);
   26050                                 internal(ios);
   26051                                 {
   26052                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26053                                     std::string ex(str, iter.base());
   26054                                     assert(ex == "0X*********9;32C05A44P+27");
   26055                                     assert(ios.width() == 0);
   26056                                 }
   26057                             }
   26058                         }
   26059                     }
   26060                     showpos(ios);
   26061                     {
   26062                         noshowpoint(ios);
   26063                         {
   26064                             ios.imbue(lc);
   26065                             {
   26066                                 ios.width(0);
   26067                                 {
   26068                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26069                                     std::string ex(str, iter.base());
   26070                                     assert(ex == "+0X9.32C05A44P+27");
   26071                                     assert(ios.width() == 0);
   26072                                 }
   26073                                 ios.width(25);
   26074                                 left(ios);
   26075                                 {
   26076                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26077                                     std::string ex(str, iter.base());
   26078                                     assert(ex == "+0X9.32C05A44P+27********");
   26079                                     assert(ios.width() == 0);
   26080                                 }
   26081                                 ios.width(25);
   26082                                 right(ios);
   26083                                 {
   26084                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26085                                     std::string ex(str, iter.base());
   26086                                     assert(ex == "********+0X9.32C05A44P+27");
   26087                                     assert(ios.width() == 0);
   26088                                 }
   26089                                 ios.width(25);
   26090                                 internal(ios);
   26091                                 {
   26092                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26093                                     std::string ex(str, iter.base());
   26094                                     assert(ex == "+********0X9.32C05A44P+27");
   26095                                     assert(ios.width() == 0);
   26096                                 }
   26097                             }
   26098                             ios.imbue(lg);
   26099                             {
   26100                                 ios.width(0);
   26101                                 {
   26102                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26103                                     std::string ex(str, iter.base());
   26104                                     assert(ex == "+0X9;32C05A44P+27");
   26105                                     assert(ios.width() == 0);
   26106                                 }
   26107                                 ios.width(25);
   26108                                 left(ios);
   26109                                 {
   26110                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26111                                     std::string ex(str, iter.base());
   26112                                     assert(ex == "+0X9;32C05A44P+27********");
   26113                                     assert(ios.width() == 0);
   26114                                 }
   26115                                 ios.width(25);
   26116                                 right(ios);
   26117                                 {
   26118                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26119                                     std::string ex(str, iter.base());
   26120                                     assert(ex == "********+0X9;32C05A44P+27");
   26121                                     assert(ios.width() == 0);
   26122                                 }
   26123                                 ios.width(25);
   26124                                 internal(ios);
   26125                                 {
   26126                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26127                                     std::string ex(str, iter.base());
   26128                                     assert(ex == "+********0X9;32C05A44P+27");
   26129                                     assert(ios.width() == 0);
   26130                                 }
   26131                             }
   26132                         }
   26133                         showpoint(ios);
   26134                         {
   26135                             ios.imbue(lc);
   26136                             {
   26137                                 ios.width(0);
   26138                                 {
   26139                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26140                                     std::string ex(str, iter.base());
   26141                                     assert(ex == "+0X9.32C05A44P+27");
   26142                                     assert(ios.width() == 0);
   26143                                 }
   26144                                 ios.width(25);
   26145                                 left(ios);
   26146                                 {
   26147                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26148                                     std::string ex(str, iter.base());
   26149                                     assert(ex == "+0X9.32C05A44P+27********");
   26150                                     assert(ios.width() == 0);
   26151                                 }
   26152                                 ios.width(25);
   26153                                 right(ios);
   26154                                 {
   26155                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26156                                     std::string ex(str, iter.base());
   26157                                     assert(ex == "********+0X9.32C05A44P+27");
   26158                                     assert(ios.width() == 0);
   26159                                 }
   26160                                 ios.width(25);
   26161                                 internal(ios);
   26162                                 {
   26163                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26164                                     std::string ex(str, iter.base());
   26165                                     assert(ex == "+********0X9.32C05A44P+27");
   26166                                     assert(ios.width() == 0);
   26167                                 }
   26168                             }
   26169                             ios.imbue(lg);
   26170                             {
   26171                                 ios.width(0);
   26172                                 {
   26173                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26174                                     std::string ex(str, iter.base());
   26175                                     assert(ex == "+0X9;32C05A44P+27");
   26176                                     assert(ios.width() == 0);
   26177                                 }
   26178                                 ios.width(25);
   26179                                 left(ios);
   26180                                 {
   26181                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26182                                     std::string ex(str, iter.base());
   26183                                     assert(ex == "+0X9;32C05A44P+27********");
   26184                                     assert(ios.width() == 0);
   26185                                 }
   26186                                 ios.width(25);
   26187                                 right(ios);
   26188                                 {
   26189                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26190                                     std::string ex(str, iter.base());
   26191                                     assert(ex == "********+0X9;32C05A44P+27");
   26192                                     assert(ios.width() == 0);
   26193                                 }
   26194                                 ios.width(25);
   26195                                 internal(ios);
   26196                                 {
   26197                                     iter = f.put(output_iterator<char*>(str), ios, '*', v);
   26198                                     std::string ex(str, iter.base());
   26199                                     assert(ex == "+********0X9;32C05A44P+27");
   26200                                     assert(ios.width() == 0);
   26201                                 }
   26202                             }
   26203                         }
   26204                     }
   26205                 }
   26206             }
   26207         }
   26208     }
   26209 #endif
   26210 }
   26211 
   26212 int main()
   26213 {
   26214     test1();
   26215     test2();
   26216     test3();
   26217     test4();
   26218     test5();
   26219     test6();
   26220     test7();
   26221     test8();
   26222     test9();
   26223     test10();
   26224     test11();
   26225     test12();
   26226     output_iterator<char*> iter;
   26227     std::locale lc = std::locale::classic();
   26228     std::locale lg(lc, new my_numpunct);
   26229     const my_facet f(1);
   26230     {
   26231         long double v = -INFINITY; ((void)v);
   26232     }
   26233     {
   26234         long double v = std::nan(""); ((void)v);
   26235     }
   26236 
   26237     {
   26238         long double v = +0.; ((void)v);
   26239     }
   26240     {
   26241         long double v = -INFINITY; ((void)v);
   26242     }
   26243     {
   26244         long double v = std::nan(""); ((void)v);
   26245     }
   26246     {
   26247         long double v = -INFINITY; ((void)v);
   26248     }
   26249     {
   26250         long double v = std::nan(""); ((void)v);
   26251     }
   26252 }
   26253