namespace std {
        typedef long unsigned int size_t;
        }
          typedef long unsigned int size_t;
          namespace std __attribute__ ((__visibility__ ("default"))) {
        template<typename _Tp> inline _Tp* __addressof(_Tp& __r) {
      }
        template<class _Sp, class _Tp> struct __traitor {
      };
        template<typename _Tp> struct __is_integer {
      };
        template<typename _Tp> struct __is_floating {
      };
        template<typename _Tp> struct __is_pointer {
      };
        template<typename _Tp> struct __is_normal_iterator {
      };
        template<typename _Tp> struct __is_arithmetic : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > {
      };
        template<typename _Tp> struct __is_scalar : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > {
      };
        }
          namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
        template<bool, typename> struct __enable_if {
      };
        }
          namespace std __attribute__ ((__visibility__ ("default"))) {
        template<typename _Iterator, bool _HasBase> struct _Iter_base {
      };
        }
          namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
        template<typename _Iterator, typename _Container> class __normal_iterator {
      protected: _Iterator _M_current;
      public: typedef _Iterator iterator_type;
      __normal_iterator() : _M_current(_Iterator()) {
    }
      };
        }
          namespace std __attribute__ ((__visibility__ ("default"))) {
        template<typename _Iterator> struct _Niter_base : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value> {
      };
        template<typename _Iterator> inline typename _Niter_base<_Iterator>::iterator_type __niter_base(_Iterator __it) {
      }
        template<typename _CharT> struct char_traits;
        }
          extern "C++" {
        namespace std {
      class exception {
    public: exception() throw() {
    }
    virtual ~exception() throw();
    };
      }
        }
          namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
        template<typename _Tp> class new_allocator {
      public: typedef size_t size_type;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      };
        }
          namespace std __attribute__ ((__visibility__ ("default"))) {
        template<typename _Tp> class allocator: public __gnu_cxx::new_allocator<_Tp> {
      public: typedef size_t size_type;
      template<typename _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
    };
      };
        template<typename _InputIterator, typename _ForwardIterator, typename _Allocator> _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) {
      try {
    }
      catch(...) {
    }
      }
        }
          namespace boost {
        template<class T> class scoped_ptr {
      private: T * px;
      public: typedef T element_type;
      explicit scoped_ptr( T * p = 0 ): px( p ) {
    }
      };
        }
          namespace std __attribute__ ((__visibility__ ("default"))) {
        template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_string;
        typedef basic_string<char> string;
        template<> struct char_traits<char> {
      typedef char char_type;
      static void assign(char_type& __c1, const char_type& __c2) {
    }
      }
        __pthread_unwind_buf_t __attribute__ ((__aligned__));
        }
          typedef int _Atomic_word;
          namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
        static inline _Atomic_word __attribute__ ((__unused__)) __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) {
      }
        }
          namespace std __attribute__ ((__visibility__ ("default"))) {
        template<typename _CharT, typename _Traits, typename _Alloc> class basic_string {
      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
      public: typedef _Traits traits_type;
      typedef _Alloc allocator_type;
      typedef typename _CharT_alloc_type::size_type size_type;
      typedef typename _CharT_alloc_type::reference reference;
      typedef typename _CharT_alloc_type::const_pointer const_pointer;
      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string> const_iterator;
      private: struct _Rep_base {
    _Atomic_word _M_refcount;
    };
      struct _Rep : _Rep_base {
    void _M_set_length_and_sharable(size_type __n) {
    }
    _CharT* _M_refdata() throw() {
    return reinterpret_cast<_CharT*>(this + 1);
    }
    void _M_dispose(const _Alloc& __a) {
    if (__builtin_expect(this != &_S_empty_rep(), false)) {
    if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) {
  _M_destroy(__a);
  }
    }
    }
    void _M_destroy(const _Alloc&) throw();
    };
      struct _Alloc_hider : _Alloc {
    _Alloc_hider(_CharT* __dat, const _Alloc& __a) : _Alloc(__a), _M_p(__dat) {
    }
    _CharT* _M_p;
    };
      public: static const size_type npos = static_cast<size_type>(-1);
      private: mutable _Alloc_hider _M_dataplus;
      _Rep* _M_rep() const {
    }
      size_type _M_limit(size_type __pos, size_type __off) const {
    }
      static _Rep& _S_empty_rep() {
    }
      public: basic_string() : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) {
    }
      ~basic_string() {
    _M_rep()->_M_dispose(this->get_allocator());
    }
      size_type length() const {
    }
      reference operator[](size_type __pos) {
    }
      basic_string& erase(size_type __pos = 0, size_type __n = npos) {
    }
      allocator_type get_allocator() const {
    }
      };
        }
          namespace boost {
        namespace detail {
      template <typename T> class empty_base {
    };
      }
        template <class T, class U, class B = ::boost::detail::empty_base<T> > struct less_than_comparable2 : B {
      };
        template <class T, class U, class B = ::boost::detail::empty_base<T> > struct equality_comparable2 : B {
      };
        namespace detail {
      struct false_t {
   };
      }
        template<class T> struct is_chained_base {
      typedef ::boost::detail::false_t value;
      };
        template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {
     };
        template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {
     };
        namespace type_traits {
      }
        template<class T> class intrusive_ptr {
      private: typedef intrusive_ptr this_type;
      public: typedef T element_type;
      intrusive_ptr(): px( 0 ) {
    }
      intrusive_ptr( T * p, bool add_ref = true ): px( p ) {
    }
      ~intrusive_ptr() {
    if( px != 0 ) intrusive_ptr_release( px );
    }
      T * operator->() const {
    return px;
    }
      typedef T * this_type::*unspecified_bool_type;
      operator unspecified_bool_type() const {
    }
      private: T * px;
      };
        }
          namespace quickbook {
        struct section_info;
        struct string_ref : boost::less_than_comparable<string_ref, boost::less_than_comparable<string_ref, std::string, boost::equality_comparable<string_ref, boost::equality_comparable<string_ref, std::string> > > > {
      public: typedef std::string::const_iterator iterator;
      private: iterator begin_, end_;
      public: string_ref() : begin_(), end_() {
    }
      };
        namespace exception_detail {
      }
        }
          extern "C++" {
        namespace std {
      class bad_cast : public exception {
    };
      }
        }
          namespace quickbook {
        template <typename T> struct intrusive_base {
      intrusive_base() : ref_count_(0) {
   }
      ~intrusive_base() {
    }
      friend void intrusive_ptr_release(T* ptr) {
    if(--ptr->ref_count_ == 0) delete ptr;
    }
      private: unsigned ref_count_;
      };
        struct id_category {
      enum categories {
    default_category = 0, numbered, generated, generated_heading, generated_section, generated_doc, explicit_id, explicit_section_id, explicit_anchor_id };
      categories c;
      };
        struct id_state;
        struct id_manager {
      id_manager();
      private: boost::scoped_ptr<id_state> state;
      };
        }
          namespace boost{
        namespace detail {
      }
        }
          namespace std __attribute__ ((__visibility__ ("default"))) {
        template<typename _Tp, typename _Ref, typename _Ptr> struct _Deque_iterator {
      };
        template<typename _Tp, typename _Alloc> class _Deque_base {
      public: typedef _Alloc allocator_type;
      typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
      _Deque_base() : _M_impl() {
    _M_initialize_map(0);
    }
      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
      struct _Deque_impl : public _Tp_alloc_type {
    _Tp** _M_map;
    size_t _M_map_size;
    iterator _M_start;
    iterator _M_finish;
    _Deque_impl() : _Tp_alloc_type(), _M_map(0), _M_map_size(0), _M_start(), _M_finish() {
    }
    };
      protected: void _M_initialize_map(size_t);
      _Deque_impl _M_impl;
      };
        template<typename _Tp, typename _Alloc = std::allocator<_Tp> > class deque : protected _Deque_base<_Tp, _Alloc> {
      };
        namespace numeric {
      enum range_check_result {
    cInRange = 0 , cNegOverflow = 1 , cPosOverflow = 2 }
      ;
      class bad_numeric_cast : public std::bad_cast {
    };
      class negative_overflow : public bad_numeric_cast {
    void operator() ( range_check_result r ) {
    if ( r == cNegOverflow ) throw negative_overflow() ;
    }
    }
      ;
      }
        }
          namespace quickbook {
        static const std::size_t max_size = 32;
        struct id_placeholder {
      };
        struct file_info;
        struct doc_info;
        struct id_state {
      boost::intrusive_ptr<file_info> current_file;
      std::deque<id_placeholder> placeholders;
      private: id_placeholder* add_id_to_section( std::string const& id, id_category category, boost::intrusive_ptr<section_info> const& section);
      };
        struct file_info : intrusive_base<file_info> {
      boost::intrusive_ptr<file_info> parent;
      boost::intrusive_ptr<doc_info> document;
      bool document_root;
      unsigned compatibility_version;
      boost::intrusive_ptr<section_info> switched_section;
      id_placeholder* original_placeholder;
      std::string doc_id_1_1;
      file_info(boost::intrusive_ptr<file_info> const& parent, unsigned compatibility_version) : parent(parent), document(parent->document), document_root(false), compatibility_version(compatibility_version), switched_section(), original_placeholder() {
   }
      };
        struct doc_info : intrusive_base<doc_info> {
      boost::intrusive_ptr<section_info> current_section;
      std::string last_title_1_1;
      std::string section_id_1_1;
      };
        struct section_info : intrusive_base<section_info> {
      boost::intrusive_ptr<section_info> parent;
      unsigned compatibility_version;
      unsigned level;
      std::string id_1_1;
      id_placeholder* placeholder_1_6;
      section_info(boost::intrusive_ptr<section_info> const& parent, unsigned compatibility_version, std::string const& id) : parent(parent), compatibility_version(compatibility_version), level(parent ? parent->level + 1 : 1), id_1_1(), placeholder_1_6(0) {
    }
      };
        id_manager::id_manager() : state(new id_state) {
      }
        namespace {
      std::string normalize_id( std::string src_id, std::size_t prefix = 0, std::size_t size = max_size) {
    std::string id;
    std::size_t src = prefix;
    std::size_t dst = prefix;
    if (src >= id.length()) {
    if (id[src] == '_') {
    }
    }
    id.erase(dst);
    }
      }
        id_placeholder* id_state::add_id_to_section( std::string const& id, id_category category, boost::intrusive_ptr<section_info> const& section) {
      std::string id_part = id;
      if (current_file->compatibility_version >= 106u && category.c < id_category::explicit_id) {
    id_part = normalize_id(id);
    }
      boost::intrusive_ptr<section_info> parent = current_file->document->current_section;
      boost::intrusive_ptr<section_info> new_section = new section_info(parent, current_file->compatibility_version, id);
      };
        }