SQLite

  ** otherwise use printf.
  */
  if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
    /* The value has no fractional part so there is nothing to round */
  }else if( n==0 ){ 
    r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
  }else{
    zBuf = sqlite3_mprintf("%#!.*f",n,r);
    if( zBuf==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
    sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
    sqlite3_free(zBuf);
  }

          iRound = -precision;
        }else if( xtype==etGENERIC ){
          if( precision==0 ) precision = 1;
          iRound = precision;
        }else{
          iRound = precision+1;
        }
        sqlite3FpDecode(&s, realvalue, iRound, 
            flag_altform2 ? 26+flag_alternateform : 16);
            /*                 ^^^^^^^^^^^^^^^^^^^--- Undocumented behavior:
            ** When both '#' and '!' flags are present, the rounding behavior
            ** is changed.  See "rule 3" in the sqlite3FpDecode docs. */
        if( s.isSpecial ){
          if( s.isSpecial==2 ){
            bufpt = flag_zeropad ? "null" : "NaN";
            length = sqlite3Strlen30(bufpt);
            break;
          }else if( flag_zeropad ){
            s.z[0] = '9';

int sqlite3Atoi(const char *z){
  int x = 0;
  sqlite3GetInt32(z, &x);
  return x;
}

/*
** z[] is the complete list of digits for a floating point conversion.
** The z[iRound] character is a 4.  This routine checks to see if the
** iRound-1 character should be rounded up even though z[iRound] is not
** a 5.
**
** Return true if the 4 is followed by at least three 9s and all digits
** past the 4 are 9s out to the limit of precision.
*/
static SQLITE_NOINLINE int shouldRoundUp(const char *z, int n, int iRound){
  int i;
  assert( z[iRound]=='4' );
  for(i=iRound+1; i<n && z[i]=='9'; i++){}
  if( i<iRound+3 ) return 0;

  return i>15;
}

/*
** Decode a floating-point value into an approximate decimal
** representation.
**
** If iRound<=0 then round to -iRound significant digits to the

**   (3)  Round up if the next digit is a 4 followed by three or
**        more 9 digits and all digits after the 4 up to the
**        antipenultimate digit are 9.  Otherwise truncate.
**
** Rule (3) is so that things like round(0.15,1) will come out as 0.2
** even though the stored value for 0.15 is really
** 0.1499999999999999944488848768742172978818416595458984375 and ought
** to round down to 0.1.  Rule (3) is only applied if mxRound==27.
**
** This routine is normally only called from printf()/format().  In that
** case, mxRound is usually 16 but is increased to 26 with the "!" flag.
** Undocumented behavior:  mxRound is 27 with the "#" and "!" flags.  The
** round() function uses this undocumented flag combination to activate
** rounding rule (3).
*/
void sqlite3FpDecode(FpDecode *p, double r, int iRound, int mxRound){
  int i;
  u64 v;
  int e, exp = 0;
  p->isSpecial = 0;
  p->z = p->zBuf;

      p->iDP++;
    }
  }
  if( iRound>0 && (iRound<p->n || p->n>mxRound) ){
    char *z = &p->zBuf[i+1];
    if( iRound>mxRound ) iRound = mxRound;
    if( z[iRound]>='5'
     || (z[iRound]=='4' && mxRound>=27 && shouldRoundUp(z, p->n, iRound))

    ){
      int j = iRound-1;
      while( 1 /*exit-by-break*/ ){
        z[j]++;
        if( z[j]<='9' ) break;
        z[j] = '0';
        if( j==0 ){