typedef int _Atomic_word;
typedef long unsigned int size_t;
namespace __gnu_cxx {
	template < typename _Tp > class new_allocator {
	      public:typedef const _Tp *const_pointer;
		typedef _Tp & reference;
	};
	static _Atomic_word __exchange_and_add_dispatch(_Atomic_word * __mem,
							int __val) {
	}
}

namespace std {
	template < typename _CharT > struct char_traits;
	class exception {
	      public:exception() throw() {
		} virtual ~ exception() throw();
	};
	class bad_cast:public exception {
	};
      template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < _Tp >
	{
	      public:template < typename _Tp1 > struct rebind {
			typedef allocator < _Tp1 > other;
		};
	};
	template < typename _CharT, typename _Traits =
	    char_traits < _CharT >, typename _Alloc =
	    allocator < _CharT > >class basic_string;
	typedef basic_string < char >string;
	template < typename _CharT, typename _Traits,
	    typename _Alloc > class basic_string {
		typedef typename _Alloc::template rebind <
		    _CharT >::other _CharT_alloc_type;
		typedef _Alloc allocator_type;
		typedef typename _CharT_alloc_type::reference reference;
	      private:struct _Rep_base {
			_Atomic_word _M_refcount;
		};
		struct _Rep:_Rep_base {
			_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_t npos =
		    static_cast < size_t > (-1);
	      private:mutable _Alloc_hider _M_dataplus;
		_Rep *_M_rep() 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_t length() const {
		} reference operator[] (size_t __pos) {
		}
		basic_string & erase(size_t __pos = 0, size_t __n = npos) {
		}
		allocator_type get_allocator() const {
	}};
	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 boost {
	template < class T > class scoped_ptr {
	      private:T * px;
	      public:typedef T element_type;
	      explicit scoped_ptr(T * p = 0):px(p) {
	}};
	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;
	};
	struct section_info;
	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;
	};
	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::string id;
			size_t src;
			size_t dst;
			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);
	};
}