Enable 'long long'
    typedef fsl_int32_t fsl_id_t
    #define FSL_ID_T_PFMT FSL_INT32_T_PFMT

    And then...
  */
  {
    char buf[80];
    int i = 0;
    f_out(("#%d: %"FSL_ID_T_PFMT" %"FSL_ID_T_PFMT" %"FSL_ID_T_PFMT"\n",
           ++i, 1, 2, 3));
    f_out(("#%d: %"FSL_SIZE_T_PFMT" %"FSL_ID_T_PFMT" %"FSL_SIZE_T_PFMT"\n",
           ++i, (fsl_size_t)1, (fsl_id_t)2, (fsl_size_t)3));
    puts("This next one fails badly because the numeric arguments "
         "are passed on as integers and the va_arg() handling extracts "
         "a larger type, effectively skipping over arguments and potentially "
         "overrunning memory (i.e. corruption):");
    f_out(("#%d: %"FSL_SIZE_T_PFMT" %"FSL_ID_T_PFMT" %"FSL_SIZE_T_PFMT"\n",
           ++i, 1, 2, 3));
    puts("The trigger is the 'll' format specifier in conjunction with "
         "integer arguments which are not strongly typed and don't match "
         "their format specifier's expected sizeof() exactly.");

    /*
      Problem has something to do with the sizeof(int) resp. sizeof(fsl_id_t)
      and the va_arg() handling of the etRADIX bits in fsl_appendf().

      The fix? Find the right combination of formatting string for integers
      in that combination. %d is apparently not correct.

      And it only appears to happen when we cross multiple levels of va_list
      handling? Namely, it happens in fsl_snprintf() but not fsl_output():
    */
    fsl_snprintf(buf, sizeof(buf),
                 "#%d: %"FSL_SIZE_T_PFMT" %"FSL_ID_T_PFMT" %"FSL_SIZE_T_PFMT"\n",
                 ++i, (fsl_size_t)1, (fsl_id_t)2, (fsl_size_t)3);
    f_out(("fsl_snprintf() says: %s\n", buf));
    puts("That one is failing differently in tcc/gcc.");
  }
#else
  rc = test_event_0();
#endif
  
  end:
  return FossilApp_err_report(0)
    ? EXIT_FAILURE : rc;
}

  }else{
    f_out(("Rather large - not dumping to console.\n"));
  }
  f_out(("Dumping mf to file [%s]\n", ofile));
  rc = fsl_buffer_to_filename(&bout, ofile);
  assert(!rc);
  seemsSafeEnough = 0;

  if(!mf.uuid){
    assert(0==mf.rid);
    f_out(("This _appears_ to be an imported/artificial manifest. "
           "Skipping UUID/SHA1 check.\n"));
  }else{
    fsl_buffer sha = fsl_buffer_empty;
    rc = fsl_sha1sum_filename(ofile, &sha);
    assert(!rc);
    f_out(("SHA of [%s] = [%b]\n", ofile, &sha));
    seemsSafeEnough = (0==fsl_strcmp(fsl_buffer_cstr(&sha),
                                     mf.uuid));
    f_out(("SHA match? %s\n",

  /**
   ** va_list counterpart to fsl_mprintf().
   */
  char * fsl_mprintfv(char const * fmt, va_list vargs );

  /**
   ** DO NOT USE: seeing corruption involving sizeof(int-types) with
   ** some specifiers when crossing multiple va_list boundaries here.
   **
   ** An sprintf(3) clone which uses fsl_appendf() for the formatting.
   ** Outputs at most n bytes to dest and returns the number
   ** of bytes output. Returns a negative value if !dest or !fmt. Returns 0
   ** without side-effects if !n or !*fmt.
   **
   ** If the destination buffer is long enough (this function returns
   ** a non-negative value less than n), this function NUL-terminates it.

      fsl_md5_update_cstr(&md5, fc->name, -1);
      rc = fsl_repo_content_get(f, fileRid, &buf);
      if(rc){
        goto end;
      }
      numBuf[0] = 0;
#if 1
      snprintf(numBuf, NumBufSize, " %u\n", (unsigned)buf.used);
#else



      /* Awaiting portable bugfix for sizeof()/format-string combination */










      fsl_snprintf(numBuf, NumBufSize, " %"FSL_SIZE_T_PFMT"\n", buf.used);


      if(0) MARKER(("numbuf=[%s]\n", numBuf));

#endif
      fsl_md5_update_cstr(&md5, numBuf, -1);
      fsl_md5_update_buffer(&md5, &buf);
    }
    if(!rc){
      fsl_md5_final(&md5, digest);
      fsl_md5_digest_to_base16(digest, hex);

    }
    return rc;
  }
}

  
/**
 ** Output state for fsl_appendf_f_mf() and friends. Used for managing
 ** the output of a fsl_deck.
 */
struct fsl_deck_out_state {
  /**
   ** Repo db handle. Needed for certain card generation bits.
   */
  fsl_db * db;
  /**
   ** The set of cards being output. We use this to delegate certain
   ** output bits.
   */
  fsl_deck const * cards;
  /**
   ** Output routine to send manifest to.
   */
  fsl_output_f out;
  /**
   ** State to pass as the first arg of this->out().
   */
  void * outState;
  /**
   ** f() result code, so that we can feed the code back through the
   ** fsl_appendf() layer. If this is non-0, processing must stop.  We
   ** "could" use this->error.code instead, but this is simple.
   */
  int rc;
  /**
   ** Counter for list-visiting routines. Must be re-set before each
   ** visit loop if the visitor makes use of this (most do not).
   */
  fsl_int_t counter;

  /**
   ** Incrementally-calculated MD5 sum of all output sent via
   ** fsl_appendf_f_mf().
   */
  fsl_md5_cx md5;

  /* Holds error state for propagating back to the client. */
  fsl_error error;

  /**
   ** Scratch buffer for fossilzing bytes and other temporary work.
   */
  fsl_buffer scratch;
};
typedef struct fsl_deck_out_state fsl_deck_out_state;
static const fsl_deck_out_state fsl_deck_out_state_empty = {
NULL/*db*/,
NULL/*cards*/,

                               fsl_int_t len){
  fsl_buffer_reset(&os->scratch);
  return os->rc = len
    ? fsl_bytes_fossilize(inp, len, &os->scratch)
    : 0;
}

/**
 ** Fossilizes b->mem to os->scratch. Returns 0 on success and all
 ** that.
 */
static int fsl_deck_fossilize_b( fsl_deck_out_state * os,
                                 fsl_buffer const * b ){
  return b->used
    ? fsl_deck_fossilize( os, b->mem, (fsl_int_t)b->used)
    : 0;
}
/**
 ** If doFossilize, fossilizes b to os->scratch and passes that result
 ** to fsl_deck_append(), otherwise uses b's contents directly for
 ** appending a card (with the given letter) to os:
 **
 ** LETTER CONTENT\\n
 **
 ** This is only useful for cards with simple buffer values.
 */
static int fsl_deck_out_letter_buf( fsl_deck_out_state * os,

static int fsl_deck_out_T( fsl_deck_out_state * os ){
  return fsl_deck_out_list_obj(os, &os->cards->T,
                                  fsl_list_v_mf_output_card_T);
}

static int fsl_deck_out_W( fsl_deck_out_state * os ){
  if(os->cards->W.used){
    fsl_deck_append(os, "W %"FSL_SIZE_T_PFMT"\n%b\n",
                    os->cards->W.used,
                    &os->cards->W );
  }
  return os->rc;
}


/* Appends the Z card to os from os' accummulated md5 hash. */
static int fsl_deck_out_Z( fsl_deck_out_state * os ){
  unsigned char digest[16];
  char md5[FSL_MD5_STRLEN+1];
  fsl_md5_final(&os->md5, digest);
  fsl_md5_digest_to_base16(digest, md5);
  assert(!md5[32]);
  os->md5.isInit = 0 /* Keep further output from updating the MD5 */;
  return fsl_deck_append(os, "Z %.*s\n", FSL_MD5_STRLEN, md5);
}

static char fsl_deck_check_required_cards(fsl_cx *f,
                                          fsl_deck const * d){
  if(fsl_deck_has_required_cards(d)) return 1;
  else{
    fsl_cx_err_set(f, FSL_RC_MF_SYNTAX,

static int fsl_deck_output_cluster( fsl_deck_out_state * os ){
  return fsl_deck_out_list_obj(os, &os->cards->M,
                                  fsl_list_v_mf_output_card_M);
}


/* Helper for fsl_deck_output_CATYPE() */
#define DOUT(LETTER) rc = fsl_deck_out_##LETTER(os); \
  if(rc || os->rc) return os->rc ? os->rc : rc

static int fsl_deck_output_control( fsl_deck_out_state * os ){
  int rc;
  /* Reminder: cards must be output in strict lexical order. */
  DOUT(D);

}

int fsl_deck_output( fsl_cx * f, fsl_deck const * cards,
                     fsl_output_f out, void * outputState ){
  static const char allowTypeAny = 0
    /* Only enable for debugging/testing. Allows outputing decks of
    ** type FSL_CATYPE_ANY, which bypasses some validation checks and
    ** may trigger other validation assertions. And may allow you to
    ** inject garbage into the repo. So be careful.
    */;

  fsl_deck_out_state OS = fsl_deck_out_state_empty;
  fsl_deck_out_state * os = &OS;
  int rc = 0;
  fsl_db * db = fsl_cx_db_repo(f);
  if(!cards || !out || !f || !db) return FSL_RC_MISUSE;

  fsl_stmt * s1 = NULL;
  int rc;
  assert(f);
  assert(db);
  assert(db->beginCount>0);
  rc = fsl_repo_filename_to_fnid(f, zFilename, &fnid);
  if(rc) return rc;




  if( zPrior && *zPrior ){
    rc = fsl_repo_filename_to_fnid(f, zPrior, &pfnid);
    if(rc) return rc;
  }else{
    pfnid = 0;
  }
  if( zFromUuid && *zFromUuid ){

#undef FCARD
}

/**
 ** Locate a file named zName in d->F.list.  Return a pointer to the
 ** appropriate fsl_mf_card object. Return NULL if not found.
 **
 ** This routine works even if p is a delta-manifest. The pointer
 ** returned might be to the baseline and d->B.baseline is loaded on
 ** demand if needed. It returns NULL if it finds a match but that
 ** match has no UUID, indicating that it was removed from the tree by
 ** this manifest.
 **
 ** We assume that filenames are in sorted order and use a binary
 ** search.
 */
fsl_mf_fcard const * fsl_deck_F_seek(fsl_deck * d, const char *zName){
  fsl_mf_fcard const *pFile;
  again:
  pFile = fsl_deck_F_seek_base(d, zName);
  if( pFile && !pFile->uuid ) return NULL
    /* File was removed from repo in this manifest. (i think?) */
    ;
  else if( !pFile && d && d->B.uuid ){
    /* Recursively check baseline manifests... */
    int rc;
    /* assert(!"force caller to load baseline so this op can be const."); */
    rc = fsl_deck_baseline_fetch(d);
    if(rc){
      assert(d->f->error.code);
    }else if( (d = d->B.baseline) ) goto again;
  }
  return pFile;
}

/**
 ** fsl_list_visitor_f() state for fsl_deck_F_find().
 */
struct FCardSearch {
  /** Filename to match against */
  char const * str;
  /** On success, this is set to the found object. */
  fsl_mf_fcard const * fc;
};
typedef struct FCardSearch FCardSearch;

/**
 ** A fsl_list_visitor_f() impl which performs a case-insensitive
 ** search for a file. state must be a (FCardSearch*). state->str
 ** is the string to search for. On success, FSL_RC_BREAK is returned
 ** and state->fc will point to the F-card which was found.
 */
static int fsl_list_v_fsl_mf_F_search_nocase(void * obj, void * state ){

}

/**
 ** Look for a file in a manifest, taking the case-insensitive option
 ** into account.  If case-insensitive is on then files in any case
 ** will match.
 */
/* static */
fsl_mf_fcard const * fsl_deck_F_find(fsl_deck *d, const char *zName){
  assert(d->f);
  if( !d->f->cache.caseInsensitive ) return fsl_deck_F_seek(d, zName);
  else{
    FCardSearch state;
    state.str = zName;
    state.fc = NULL;
    while(d && !state.fc){
      fsl_list_visit(&d->F.list, 0, fsl_list_v_fsl_mf_F_search_nocase, &state);
      if(!state.fc && d->B.uuid){
        /* assert(!"force caller to load baseline so this op can be const."); */
        fsl_deck_baseline_fetch(d);
        d = d->B.baseline;
      }
    }
    return state.fc;
  }
}

/**


 ** Add mlink table entries associated with manifest cid, pChild.  The
 ** parent manifest is pid, pParent.  One of either pChild or pParent
 ** will be NULL and it will be computed based on cid/pid.
 **
 ** A single mlink entry is added for every file that changed content,
 ** name, and/or permissions going from pid to cid.
 **

  else if( d->type==FSL_CATYPE_WIKI ){
    fsl_buffer buf = fsl_buffer_empty;
    fsl_id_t tagid;
    fsl_id_t prior;
    char zLength[40] = {0};
    char const * zWiki;
    char const * zTag;
    fsl_size_t nWiki = 0;
    rc = fsl_buffer_appendf(&buf, "wiki-%b", &d->L);
    if(rc) goto wiki_end;
    zTag = fsl_buffer_cstr(&buf);
    tagid = fsl_repo_tag_id( f, zTag, 1 );
    if(tagid<=0){
      rc = f->error.code ? f->error.code :
        fsl_cx_err_set(f, FSL_RC_RANGE,
                       "Got unexpected RID (%"FSL_ID_T_PFMT") "
                       "for tag [%s].",
                       tagid, zTag);
      goto wiki_end;
    }
    zWiki = d->W.used ? fsl_buffer_cstr(&d->W) : "";
    while( *zWiki && fsl_isspace(*zWiki) ){
      ++zWiki;
      /* Historical behaviour: strip leading spaces. */

    }
    nWiki = fsl_strlen(zWiki)
      /* Reminder: use strlen instead of d->W.used in case
         just in case that one contains embedded NULs
         in the content.
      */;
#if 1

    snprintf(zLength, sizeof(zLength), " %"FSL_SIZE_T_PFMT, nWiki);
#else
    /* Awaiting portable bugfix for sizeof()/format-string combination */
    fsl_snprintf( zLength, sizeof(zLength), "%"FSL_SIZE_T_PFMT, nWiki);
#endif
    rc = fsl_repo_tag_insert(f, FSL_TAGTYPE_ADD, zTag, zLength,
                             rid, d->D, rid, NULL );
    if(rc) goto wiki_end;
    buf.used = 0 /* re-use memory for comment text */;
    zTag = zWiki = NULL;
    prior = fsl_db_g_id(db, 0,
      "SELECT rid FROM tagxref"
      " WHERE tagid=%"FSL_ID_T_PFMT" AND mtime<%"FSL_JULIAN_T_PFMT
      " ORDER BY mtime DESC",
      tagid, d->D
    );
    if(prior>0){
      rc = fsl_repo_content_deltify(f, prior, rid, 0);
      if(rc) goto wiki_end;
    }

  if( d->type==FSL_CATYPE_EVENT ){
    fsl_buffer buf = fsl_buffer_empty;
    fsl_id_t tagid;
    fsl_id_t prior, subsequent;
    char zLength[40] = {0};
    char const * zWiki;
    char const * zTag;
    fsl_size_t nWiki = 0;
    rc = fsl_buffer_appendf(&buf, "event-%b", &d->E.uuid);
    if(rc) goto wiki_end;
    zTag = fsl_buffer_cstr(&buf);
    tagid = fsl_repo_tag_id( f, zTag, 1 );
    if(tagid<=0){
      rc = f->error.code ? f->error.code :
        fsl_cx_err_set(f, FSL_RC_RANGE,
                       "Got unexpected RID (%"FSL_ID_T_PFMT") "
                       "for tag [%s].",
                       tagid, zTag);
      goto event_end;
    }
    zWiki = d->W.used ? fsl_buffer_cstr(&d->W) : "";
    while( *zWiki && fsl_isspace(*zWiki) ){
      ++zWiki;
      /* Historical behaviour: strip leading spaces. */

    }
    nWiki = fsl_strlen(zWiki);
#if 1

    snprintf(zLength, sizeof(zLength), " %"FSL_SIZE_T_PFMT, nWiki);
#else
    /* Awaiting portable bugfix for sizeof()/format-string combination */
    fsl_snprintf( zLength, sizeof(zLength), "%"FSL_SIZE_T_PFMT, nWiki);
#endif
    rc = fsl_repo_tag_insert(f, FSL_TAGTYPE_ADD, zTag, zLength,
                             rid, d->D, rid, NULL );
    if(rc) goto event_end;
    prior = fsl_db_g_id(db, 0,
                       "SELECT rid FROM tagxref"
                       " WHERE tagid=%"FSL_ID_T_PFMT

         FSL_CATYPE_CONTROL==d->type ||
         FSL_CATYPE_WIKI==d->type ||
         FSL_CATYPE_TICKET==d->type ||
         FSL_CATYPE_ATTACHMENT==d->type ||
         FSL_CATYPE_EVENT==d->type);

  d->rid = fsl_repo_uuid_to_rid(f, fsl_buffer_cstr(&selfHash));
  /* assert(d->rid>0);
     can't run test manifest through this if we assert here.
   */
  if(d->rid>0){




    fsl_free(d->uuid);
    d->uuid = fsl_buffer_str(&selfHash) /* transfer ownership */;
  }else{
    fsl_buffer_clear(&selfHash);
  }
  return rc;

  bailout:
  assert(0 != rc);
  fsl_buffer_clear(&selfHash);
  if(zMsg){
    rc = fsl_cx_err_set(f, rc, "%s", zMsg);