---

base.LexicalFormatterPrimitives.h

/*----------------------------------------------------------------------------
  SWORD 2000 - Software With Objects for Rapid Development
  Copyright (C) 2003 Eric NICOLAS
  ----------------------------------------------------------------------------
  SWORD is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  SWORD is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with SWORD; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  --------------------------------------------------------------------------*/
#ifndef _SWORD_BASE_LEXICALFORMATTER_PRIMITIVES_
#define _SWORD_BASE_LEXICALFORMATTER_PRIMITIVES_

#include <limits>

namespace sword {

  // ---
  // --- All available formatting primitives
  // ---
  //
  // The common calling convention is:
  //    char *_format_OPTIONS<TYPE>(TYPE value, word width, word precision, char *buffer, word bufferLen)
  //
  //    value     : the value to format
  //    width     : the display width (actual use depends on formatter)
  //    precision : the display precision (actual use depends on formatter)
  //    buffer    : target buffer, MUST be large enough (or else memory bug)
  //    bufferLen : length of the target buffer
  //    <return>  : pointer to the built string (usually <> buffer)
  //
  // The OPTIONS describe what the function does exactly. It is a series
  // of codes separated by underscores. They must be exactly in the following
  // order:
  //    1. 'U' -> works on unsigned integer
  //       'I' -> works on signed integer
  //    2. 'g' -> no digits groupping
  //       'G' -> with digits groupping
  //    3. 'D' -> normal, in base 10 (decimal)
  //       'O' -> display in base 8  (octal)
  //       'x' -> display in base 16 (hexadecimal, lower-case digits)
  //       'X' -> display in base 16 (hexadecimal, upper-case digits)
  //    4. 'L' -> left-aligned in the field
  //       'C' -> centered in the field
  //       'R' -> right-aligned in the field
  //   For signed integers, and only in decimal display:
  //    5. 'N' -> negative only sign display
  //       'F' -> finance display
  //       'E' -> explicit sign display
  //   For octal and hexadecimal only:
  //    6. 'p' -> normal display
  //       'P' -> add a prefix
  //
  // Example:
  //   _format_U_G_X_L_P<T>(...)
  //
  //   this formatter takes an unsigned int and displays it in hexadecimal 
  //   format with upper case letters, groupping the digits and adding a 
  //   0X prefix up front. The result will be left-aligned within the field.
  //
  // Here are all the possible combinaisons:
  // _format_U_g_D_L   <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_D_C   <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_D_R   <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_D_L   <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_D_C   <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_D_R   <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_O_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_O_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_O_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_O_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_O_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_O_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_O_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_O_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_O_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_O_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_O_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_O_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_x_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_x_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_x_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_x_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_x_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_x_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_x_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_x_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_x_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_x_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_x_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_x_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_X_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_X_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_X_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_X_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_X_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_X_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_X_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_X_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_g_X_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_X_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_X_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_U_G_X_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_L_N <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_C_N <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_R_N <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_L_N <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_C_N <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_R_N <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_L_F <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_C_F <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_R_F <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_L_F <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_C_F <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_R_F <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_L_E <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_C_E <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_D_R_E <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_L_E <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_C_E <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_D_R_E <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_O_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_O_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_O_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_O_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_O_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_O_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_O_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_O_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_O_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_O_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_O_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_O_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_x_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_x_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_x_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_x_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_x_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_x_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_x_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_x_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_x_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_x_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_x_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_x_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_X_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_X_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_X_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_X_L_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_X_C_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_X_R_p <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_X_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_X_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_g_X_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_X_L_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_X_C_P <T>(T value, word width, word precision, char *buffer, word bufferLen)
  // _format_I_G_X_R_P <T>(T value, word width, word precision, char *buffer, word bufferLen)

  // Helpers

  //@TODO : implement this using the Locale
  inline char _getThousandChar()
  {
    return '_';
  }

  template<typename INTT> class formatterTraits {};
  template<> class formatterTraits<int8>  { public: typedef word8  Type; };
  template<> class formatterTraits<int16> { public: typedef word16 Type; };
  template<> class formatterTraits<int32> { public: typedef word32 Type; };
  template<> class formatterTraits<int64> { public: typedef word64 Type; };
  template<> class formatterTraits<int>   { public: typedef word   Type; };

  // Generated Code

  template<typename T>
  inline char *_format_U_g_D_L(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_D_C(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_D_R(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_D_L(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_D_C(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_D_R(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_O_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_O_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_O_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_O_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_O_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_O_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_O_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_O_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_O_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_O_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_O_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_O_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_x_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_x_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_x_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_x_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_x_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_x_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_x_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_x_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_x_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_x_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_x_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_x_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_X_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_X_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_X_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_X_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_X_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_X_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_X_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_X_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_g_X_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_X_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_X_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_U_G_X_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    T value = value0;
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_L_N(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_C_N(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_R_N(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_L_N(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_C_N(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_R_N(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_L_F(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
          *p-- = ')';
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '(';
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_C_F(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
          *p-- = ')';
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '(';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_R_F(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
          *p-- = ')';
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '(';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_L_F(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
          *p-- = ')';
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '(';
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_C_F(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
          *p-- = ')';
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '(';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_R_F(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
          *p-- = ')';
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '(';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_L_E(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    else
    {
      *p-- = '+';
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_C_E(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    else
    {
      *p-- = '+';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_D_R_E(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    do
    {
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    else
    {
      *p-- = '+';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_L_E(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    else
    {
      *p-- = '+';
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_C_E(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    else
    {
      *p-- = '+';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_D_R_E(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789";
    register T value = value0;
    bool negative = value < 0;
    if (negative)
    {
       value = -value;
    }
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 10];
        value /= 10;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 3)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    if (negative)
    {
      *p-- = '-';
    }
    else
    {
      *p-- = '+';
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_O_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_O_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_O_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_O_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_O_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_O_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_O_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_O_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_O_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_O_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_O_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_O_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "01234567";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 8];
        value /= 8;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_x_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_x_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_x_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_x_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_x_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_x_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_x_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_x_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_x_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_x_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_x_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_x_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789abcdef";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'x';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_X_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_X_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_X_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_X_L_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_X_C_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_X_R_p(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_X_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_X_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_g_X_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    do
    {
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_X_L_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p0++ = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_X_C_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
      if (p > p0-width-1)
      {
        *p0++ = ' ';
      }
    }
    *p0 = '\0';
    return p+1;
  }

  template<typename T>
  inline char *_format_I_G_X_R_P(T value0, word width, word precision, char *buffer, word bufferLen)
  {
    char *p0 = buffer+bufferLen-width-1;
    register char *p  = p0 - 1;

    const char *letters = "0123456789ABCDEF";
    typename formatterTraits<T>::Type value = static_cast<typename formatterTraits<T>::Type>(value0);
    word n = 0;
    char thousandChar = _getThousandChar();
    word level = 0;
    do
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
        *p-- = letters[value % 16];
        value /= 16;
      ++n;
    }
    while(value);
    
    while(n < precision)
    {
      if (level == 4)
      {
        *p-- = thousandChar;
        level = 1;
      }
      else
        ++level;
      *p-- = '0';
      ++n;
    }
    *p-- = 'X';
    *p-- = '0';
    while(p > p0-width-1)
    {
      *p-- = ' ';
    }
    *p0 = '\0';
    return p+1;
  }

} // namespace sword

#endif // _SWORD_BASE_LEXICALFORMATTER_PRIMITIVES_

---