struct mkd_renderer make;
  struct Blob refs;
  char_trigger active_char[256];
  int iDepth;                    /* Depth of recursion */
  int nBlobCache;                /* Number of entries in aBlobCache */
  struct Blob *aBlobCache[20];   /* Cache of Blobs available for reuse */

  struct {
    Blob all;    /* array of footnotes */
    int nLbled;  /* number of labeled footnotes found during the first pass */
    int nMarks;  /* count distinct indices found in the second pass */
  } notes;
};

/* html_tag -- structure for quick HTML tag search (inspired from discount) */
struct html_tag {
  const char *text;
  int size;
};

  struct render *rndr,
  const char *data,
  size_t size
){
  struct footnote *fn = NULL;
  struct Blob *id = new_work_buffer(rndr);
  if( build_ref_id(id, data, size)<0 ) goto cleanup;
  fn = bsearch(id, blob_buffer(&rndr->notes.all),
               rndr->notes.nLbled,
               sizeof (struct footnote),
               cmp_link_ref);
  if( !fn ) goto cleanup;

  if( fn->index == 0 ){  /* the first reference to the footnote */
    assert( fn->nUsed == 0 );
    fn->index = ++(rndr->notes.nMarks);
  }
  fn->nUsed++;
  assert( fn->index > 0 );
  assert( fn->nUsed > 0 );
cleanup:
  release_work_buffer( rndr, id );
  return fn;
}
/* Adds unlabeled footnote to the rndr.
 * If text is blank then returns 0,
 * otherwise returns the address of the added footnote. */
static inline const struct footnote* add_inline_footnote(
  struct render *rndr,
  const char *text,
  size_t size
){
  struct footnote fn = { empty_blob, empty_blob, 0, 0 };
  while(size && (*text==' ' || *text=='\t')){ text++; size--; }
  if(!size) return 0;
  fn.index = ++(rndr->notes.nMarks);
  fn.nUsed = 1;
  assert( fn.index > 0 );
  blob_append(&fn.text, text, size);
  blob_append(&rndr->notes.all, (char *)&fn, sizeof fn);
  return (struct footnote*)( blob_buffer(&rndr->notes.all)
                            +( blob_size(&rndr->notes.all)-sizeof fn ));
}

/* Return the offset of the matching closing bracket or 0 if not found.
 * begin[0] must be either '[' or '('          */
static inline size_t matching_bracket_offset(
  const char* begin,
  const char* end

  /* filling the render structure */
  if( !rndrer ) return;
  rndr.make = *rndrer;
  rndr.nBlobCache = 0;
  rndr.iDepth = 0;
  rndr.refs  = empty_blob;
  rndr.notes.all = empty_blob;
  rndr.notes.nMarks = 0;
  for(i=0; i<256; i++) rndr.active_char[i] = 0;
  if( (rndr.make.emphasis
    || rndr.make.double_emphasis
    || rndr.make.triple_emphasis)
   && rndr.make.emph_chars
  ){
    for(i=0; rndr.make.emph_chars[i]; i++){

  /* first pass: iterate over lines looking for references,
   * copying everything else into "text" */
  beg = 0;
  for(const size_t size = blob_size(ib); beg<size ;){
    const char* const data = blob_buffer(ib);
    if( is_ref(data, beg, size, &end, &rndr.refs) ){
      beg = end;
    }else if(is_footnote(data, beg, size, &end, &rndr.notes.all)){
      /* FIXME: fossil_print("\nfootnote found at %i\n", beg); */
      beg = end;
    }else{ /* skipping to the next line */
      end = beg;
      while( end<size && data[end]!='\n' && data[end]!='\r' ){
        end += 1;
      }
      /* adding the line body if present */
      if( end>beg ) blob_append(&text, data + beg, end - beg);
      while( end<size && (data[end]=='\n' || data[end]=='\r') ){
        /* add one \n per newline */
        if( data[end]=='\n' || (end+1<size && data[end+1]!='\n') ){
          blob_append_char(&text, '\n');
        }
        end += 1;
      }
      beg = end;
    }
  }
  assert( rndr.notes.nMarks==0 );
  /* sorting the reference array */
  if( blob_size(&rndr.refs) ){
    qsort(blob_buffer(&rndr.refs),
          blob_size(&rndr.refs)/sizeof(struct link_ref),
          sizeof(struct link_ref),
          cmp_link_ref_sort);
  }
  rndr.notes.nLbled = COUNT_FOOTNOTES(&rndr.notes.all);
  /* sorting the footnotes array by id */
  if( rndr.notes.nLbled ){
    qsort(blob_buffer(&rndr.notes.all), rndr.notes.nLbled,
          sizeof(struct footnote), cmp_link_ref_sort);
  }

  /* second pass: actual rendering */
  if( rndr.make.prolog ) rndr.make.prolog(ob, rndr.make.opaque);
  parse_block(ob, &rndr, blob_buffer(&text), blob_size(&text));

  fn = (struct footnote*)blob_buffer(&rndr.notes.all);
  if(rndr.notes.nMarks && rndr.make.footnote_item && rndr.make.footnotes){
    Blob * one_item  = new_work_buffer(&rndr);
    Blob * all_items = new_work_buffer(&rndr);
    qsort( fn, COUNT_FOOTNOTES(&rndr.notes.all), sizeof(struct footnote),
           cmp_footnote_sort /* sort footnotes by index */ );
    blob_reset( all_items );
    for(i=0; i<rndr.notes.nMarks; i++){
      assert( fn[i].index == i+1 );

      blob_reset( one_item );
      parse_inline( one_item, &rndr, blob_buffer(&fn[i].text),
                    blob_size(&fn[i].text));
      rndr.make.footnote_item( all_items, one_item, i+1, fn[i].nUsed, rndr.make.opaque);
    }

  end = blob_size(&rndr.refs)/sizeof(struct link_ref);
  for(i=0; i<end; i++){
    blob_reset(&lr[i].id);
    blob_reset(&lr[i].link);
    blob_reset(&lr[i].title);
  }
  blob_reset(&rndr.refs);
  end = COUNT_FOOTNOTES(&rndr.notes.all);
  for(i=0; i<end; i++){
    if(blob_size(&fn[i].id)) blob_reset(&fn[i].id);
    blob_reset(&fn[i].text);
  }
  blob_reset(&rndr.notes.all);
  for(i=0; i<rndr.nBlobCache; i++){
    fossil_free(rndr.aBlobCache[i]);
  }
}