/* gtkdocmarkdownparser.c generated by valac, the Vala compiler
 * generated from gtkdocmarkdownparser.vala, do not modify */

/* gtkdocmarkdownparser.vala
 *
 * Copyright (C) 2014 Florian Brosch
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 *  Florian Brosch <flo.brosch@gmail.com>
 */

#include "valadoc.h"
#include <valagee.h>
#include <glib-object.h>
#include <glib.h>
#include <stdlib.h>
#include <string.h>

#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif

enum  {
	VALADOC_GTKDOC_MARKDOWN_PARSER_0_PROPERTY,
	VALADOC_GTKDOC_MARKDOWN_PARSER_NUM_PROPERTIES
};
static GParamSpec* valadoc_gtkdoc_markdown_parser_properties[VALADOC_GTKDOC_MARKDOWN_PARSER_NUM_PROPERTIES];
#define _valadoc_parser_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_parser_unref (var), NULL)))
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _valadoc_api_tree_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_api_tree_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _valadoc_importer_internal_id_registrar_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_importer_internal_id_registrar_unref (var), NULL)))
#define _valadoc_api_source_comment_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_api_source_comment_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
#define _g_match_info_unref0(var) ((var == NULL) ? NULL : (var = (g_match_info_unref (var), NULL)))
#define _vala_map_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_iterator_unref (var), NULL)))
#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))

#define VALADOC_GTKDOC_TYPE_CONTENT_TO_STRING_ERROR (valadoc_gtkdoc_content_to_string_error_get_type ())
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

struct _ValadocGtkdocMarkdownParserPrivate {
	ValadocParser* parser;
	ValadocContentContentFactory* _factory;
	ValadocSettings* _settings;
	ValadocErrorReporter* _reporter;
	ValadocApiTree* _tree;
	ValaArrayList* _stack;
	ValadocToken* preserved_token;
	GRegex* regex_source_lang;
	ValadocImporterInternalIdRegistrar* id_registrar;
	ValadocGirMetaData* metadata;
	ValadocApiGirSourceComment* gir_comment;
	ValadocApiNode* element;
};

typedef enum  {
	VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR_UNEXPECTED_ELEMENT
} ValadocGtkdocContentToStringError;
#define VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR valadoc_gtkdoc_content_to_string_error_quark ()

static gint ValadocGtkdocMarkdownParser_private_offset;
static gpointer valadoc_gtkdoc_markdown_parser_parent_class = NULL;
static ValadocResourceLocatorIface * valadoc_gtkdoc_markdown_parser_valadoc_resource_locator_parent_iface = NULL;

static void valadoc_gtkdoc_markdown_parser_add_text (ValadocGtkdocMarkdownParser* self,
                                              ValadocToken* token,
                                              GError** error);
static void _valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action (ValadocToken* token,
                                                                         gpointer self,
                                                                         GError** error);
static void __lambda12_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static gboolean valadoc_gtkdoc_markdown_parser_is_error_parameter (ValadocGtkdocMarkdownParser* self,
                                                            const gchar* name);
 G_GNUC_INTERNAL gchar* valadoc_importer_helper_resolve_parameter_ctype (ValadocApiTree* tree,
                                                        ValadocApiNode* element,
                                                        const gchar* parameter_name,
                                                        gchar** param_name,
                                                        gchar** param_array_name,
                                                        gboolean* is_return_type_len);
static void valadoc_gtkdoc_markdown_parser_push (ValadocGtkdocMarkdownParser* self,
                                          GObject* element);
static void ___lambda12__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void __lambda13_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static gboolean valadoc_gtkdoc_markdown_parser_is_literal (ValadocGtkdocMarkdownParser* self,
                                                    const gchar* str);
static void valadoc_gtkdoc_markdown_parser_add_symbol_link (ValadocGtkdocMarkdownParser* self,
                                                     const gchar* symbol,
                                                     gboolean accept_plural);
static void ___lambda13__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void __lambda14_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static void ___lambda14__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void __lambda15_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static void ___lambda15__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void __lambda16_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static void ___lambda16__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void valadoc_gtkdoc_markdown_parser_preserve_token (ValadocGtkdocMarkdownParser* self,
                                                    ValadocToken* token,
                                                    GError** error);
static void _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action (ValadocToken* token,
                                                                               gpointer self,
                                                                               GError** error);
static void __lambda17_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static gchar* valadoc_gtkdoc_markdown_parser_pop_preserved_link (ValadocGtkdocMarkdownParser* self);
static void ___lambda17__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda18_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void valadoc_gtkdoc_markdown_parser_add_content_string (ValadocGtkdocMarkdownParser* self,
                                                        const gchar* str);
static void valadoc_gtkdoc_markdown_parser_add_value (ValadocGtkdocMarkdownParser* self,
                                               ValadocToken* token,
                                               GError** error);
static void ___lambda18__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda19_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda19__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda20_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static GObject* valadoc_gtkdoc_markdown_parser_peek (ValadocGtkdocMarkdownParser* self,
                                              gint offset);
static void ___lambda20__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda21_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda21__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda22_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda22__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda23_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
 G_GNUC_INTERNAL void valadoc_content_link_set_id_registrar (ValadocContentLink* self,
                                            ValadocImporterInternalIdRegistrar* value);
static void ___lambda23__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda24_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda24__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda25_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda25__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda26_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda26__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda27_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda27__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda28_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda28__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda29_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static inline gchar* valadoc_gtkdoc_markdown_parser_run_to_string (ValadocGtkdocMarkdownParser* self,
                                                     ValadocContentRun* run,
                                                     const gchar* rule_name,
                                                     GError** error);
static inline gchar* valadoc_gtkdoc_markdown_parser_fix_resource_path (ValadocGtkdocMarkdownParser* self,
                                                         const gchar* path);
static gchar* valadoc_gtkdoc_markdown_parser_pop_preserved_path (ValadocGtkdocMarkdownParser* self);
static void ___lambda29__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda30_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda30__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda31_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda31__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda32_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda32__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda33_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda33__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda34_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda34__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda35_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static ValadocContentSourceCodeLanguage* _valadoc_content_source_code_language_dup (ValadocContentSourceCodeLanguage* self);
 G_GNUC_INTERNAL gboolean valadoc_highlighter_xml_scanner_is_xml (const gchar* source);
static void ___lambda35__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void _valadoc_gtkdoc_markdown_parser_add_value_valadoc_token_type_action (ValadocToken* token,
                                                                          gpointer self,
                                                                          GError** error);
static void __lambda36_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda36__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda37_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static GObject* valadoc_gtkdoc_markdown_parser_pop (ValadocGtkdocMarkdownParser* self);
static void ___lambda37__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda38_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda38__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda39_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda39__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda40_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda40__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda41_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda41__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda42_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda42__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda43_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda43__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda44_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda44__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda45_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda45__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda46_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda46__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda47_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda47__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda48_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda48__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda49_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda49__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda50_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static void ___lambda50__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void __lambda51_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static void ___lambda51__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void __lambda52_ (ValadocGtkdocMarkdownParser* self,
                  ValadocToken* token,
                  GError** error);
static void ___lambda52__valadoc_token_type_action (ValadocToken* token,
                                             gpointer self,
                                             GError** error);
static void __lambda53_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda53__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda54_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda54__valadoc_rule_action (gpointer self,
                                       GError** error);
static void __lambda55_ (ValadocGtkdocMarkdownParser* self,
                  GError** error);
static void ___lambda55__valadoc_rule_action (gpointer self,
                                       GError** error);
static ValadocContentComment* _valadoc_gtkdoc_markdown_parser_parse (ValadocGtkdocMarkdownParser* self,
                                                              ValadocApiSourceComment* comment);
static ValadocContentTaglet* _valadoc_gtkdoc_markdown_parser_parse_block_taglet (ValadocGtkdocMarkdownParser* self,
                                                                          ValadocApiSourceComment* comment,
                                                                          const gchar* taglet_name);
static ValadocContentNote* _valadoc_gtkdoc_markdown_parser_parse_note (ValadocGtkdocMarkdownParser* self,
                                                                ValadocApiSourceComment* comment);
static void valadoc_gtkdoc_markdown_parser_add_taglet (ValadocGtkdocMarkdownParser* self,
                                                ValadocContentComment** comment,
                                                ValadocContentTaglet* taglet);
static void valadoc_gtkdoc_markdown_parser_add_note (ValadocGtkdocMarkdownParser* self,
                                              ValadocContentComment** comment,
                                              ValadocContentNote* note);
 G_GNUC_INTERNAL void valadoc_importer_helper_extract_short_desc (ValadocContentComment* comment,
                                                 ValadocContentContentFactory* factory);
 G_GNUC_INTERNAL void valadoc_taglets_param_set_is_c_self_param (ValadocTagletsParam* self,
                                                gboolean value);
 G_GNUC_INTERNAL void valadoc_taglets_param_set_parameter_name (ValadocTagletsParam* self,
                                               const gchar* value);
 G_GNUC_INTERNAL void valadoc_taglets_link_set_c_accept_plural (ValadocTagletsLink* self,
                                               gboolean value);
 G_GNUC_INTERNAL void valadoc_taglets_link_set_symbol_name (ValadocTagletsLink* self,
                                           const gchar* value);
static void valadoc_gtkdoc_markdown_parser_inline_to_string (ValadocGtkdocMarkdownParser* self,
                                                      ValadocContentInline* element,
                                                      const gchar* rule_name,
                                                      GString* builder,
                                                      GError** error);
VALA_EXTERN GQuark valadoc_gtkdoc_content_to_string_error_quark (void);
 G_GNUC_INTERNAL GType valadoc_gtkdoc_content_to_string_error_get_type (void) G_GNUC_CONST ;
static gchar* valadoc_gtkdoc_markdown_parser_real_resolve (ValadocResourceLocator* base,
                                                    const gchar* path);
static void valadoc_gtkdoc_markdown_parser_finalize (GObject * obj);
static GType valadoc_gtkdoc_markdown_parser_get_type_once (void);
static void _vala_array_destroy (gpointer array,
                          gssize array_length,
                          GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array,
                       gssize array_length,
                       GDestroyNotify destroy_func);

static inline gpointer
valadoc_gtkdoc_markdown_parser_get_instance_private (ValadocGtkdocMarkdownParser* self)
{
	return G_STRUCT_MEMBER_P (self, ValadocGtkdocMarkdownParser_private_offset);
}

static gpointer
_g_object_ref0 (gpointer self)
{
	return self ? g_object_ref (self) : NULL;
}

static gpointer
_valadoc_api_tree_ref0 (gpointer self)
{
	return self ? valadoc_api_tree_ref (self) : NULL;
}

ValadocGtkdocMarkdownParser*
valadoc_gtkdoc_markdown_parser_construct (GType object_type,
                                          ValadocSettings* settings,
                                          ValadocErrorReporter* reporter,
                                          ValadocApiTree* tree,
                                          ValadocModuleLoader* _modules)
{
	ValadocGtkdocMarkdownParser * self = NULL;
	ValadocGtkdocMarkdownScanner* scanner = NULL;
	ValadocGtkdocMarkdownScanner* _tmp0_;
	ValadocParser* _tmp1_;
	ValadocParser* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocSettings* _tmp4_;
	ValadocErrorReporter* _tmp5_;
	ValadocApiTree* _tmp6_;
	GError* _inner_error0_ = NULL;
	g_return_val_if_fail (settings != NULL, NULL);
	g_return_val_if_fail (reporter != NULL, NULL);
	g_return_val_if_fail (_modules != NULL, NULL);
	self = (ValadocGtkdocMarkdownParser*) g_object_new (object_type, NULL);
	_tmp0_ = valadoc_gtkdoc_markdown_scanner_new (settings);
	scanner = _tmp0_;
	_tmp1_ = valadoc_parser_new (settings, (ValadocScanner*) scanner, reporter);
	_valadoc_parser_unref0 (self->priv->parser);
	self->priv->parser = _tmp1_;
	_tmp2_ = self->priv->parser;
	valadoc_scanner_set_parser ((ValadocScanner*) scanner, _tmp2_);
	_tmp3_ = valadoc_content_content_factory_new (settings, (ValadocResourceLocator*) self, _modules);
	_g_object_unref0 (self->priv->_factory);
	self->priv->_factory = _tmp3_;
	_tmp4_ = _g_object_ref0 (settings);
	_g_object_unref0 (self->priv->_settings);
	self->priv->_settings = _tmp4_;
	_tmp5_ = _g_object_ref0 (reporter);
	_g_object_unref0 (self->priv->_reporter);
	self->priv->_reporter = _tmp5_;
	_tmp6_ = _valadoc_api_tree_ref0 (tree);
	_valadoc_api_tree_unref0 (self->priv->_tree);
	self->priv->_tree = _tmp6_;
	valadoc_gtkdoc_markdown_parser_init_rules (self);
	{
		GRegex* _tmp7_ = NULL;
		GRegex* _tmp8_;
		GRegex* _tmp9_;
		_tmp8_ = g_regex_new ("^<!--[ \t]+language=\"([A-Za-z]*)\"[ \t]+-->", 0, 0, &_inner_error0_);
		_tmp7_ = _tmp8_;
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			goto __catch0_g_error;
		}
		_tmp9_ = _tmp7_;
		_tmp7_ = NULL;
		_g_regex_unref0 (self->priv->regex_source_lang);
		self->priv->regex_source_lang = _tmp9_;
		_g_regex_unref0 (_tmp7_);
	}
	goto __finally0;
	__catch0_g_error:
	{
		g_clear_error (&_inner_error0_);
		g_assert_not_reached ();
	}
	__finally0:
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		_g_object_unref0 (scanner);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
		g_clear_error (&_inner_error0_);
		return NULL;
	}
	_g_object_unref0 (scanner);
	return self;
}

ValadocGtkdocMarkdownParser*
valadoc_gtkdoc_markdown_parser_new (ValadocSettings* settings,
                                    ValadocErrorReporter* reporter,
                                    ValadocApiTree* tree,
                                    ValadocModuleLoader* _modules)
{
	return valadoc_gtkdoc_markdown_parser_construct (VALADOC_GTKDOC_TYPE_MARKDOWN_PARSER, settings, reporter, tree, _modules);
}

static void
_valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action (ValadocToken* token,
                                                                    gpointer self,
                                                                    GError** error)
{
	valadoc_gtkdoc_markdown_parser_add_text ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda12_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	ValadocApiGirSourceComment* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	ValadocContentRun* _tmp69_;
	g_return_if_fail (token != NULL);
	_run = NULL;
	_tmp0_ = valadoc_token_get_value (token);
	_tmp1_ = _tmp0_;
	_tmp2_ = self->priv->gir_comment;
	_tmp3_ = valadoc_api_gir_source_comment_get_instance_param_name (_tmp2_);
	_tmp4_ = _tmp3_;
	if (g_strcmp0 (_tmp1_, _tmp4_) == 0) {
		ValadocContentContentFactory* _tmp5_;
		ValadocContentRun* _tmp6_;
		ValadocContentRun* _tmp7_;
		ValaList* _tmp8_;
		ValaList* _tmp9_;
		ValadocContentContentFactory* _tmp10_;
		ValadocContentText* _tmp11_;
		ValadocContentText* _tmp12_;
		_tmp5_ = self->priv->_factory;
		_tmp6_ = valadoc_content_content_factory_create_run (_tmp5_, VALADOC_CONTENT_RUN_STYLE_LANG_KEYWORD);
		_g_object_unref0 (_run);
		_run = _tmp6_;
		_tmp7_ = _run;
		_tmp8_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = self->priv->_factory;
		_tmp11_ = valadoc_content_content_factory_create_text (_tmp10_, "this");
		_tmp12_ = _tmp11_;
		vala_collection_add ((ValaCollection*) _tmp9_, (ValadocContentInline*) _tmp12_);
		_g_object_unref0 (_tmp12_);
	} else {
		const gchar* _tmp13_;
		const gchar* _tmp14_;
		_tmp13_ = valadoc_token_get_value (token);
		_tmp14_ = _tmp13_;
		if (valadoc_gtkdoc_markdown_parser_is_error_parameter (self, _tmp14_)) {
			ValadocContentContentFactory* _tmp15_;
			ValadocContentRun* _tmp16_;
			ValadocContentRun* _tmp17_;
			ValaList* _tmp18_;
			ValaList* _tmp19_;
			ValadocContentContentFactory* _tmp20_;
			ValadocContentText* _tmp21_;
			ValadocContentText* _tmp22_;
			_tmp15_ = self->priv->_factory;
			_tmp16_ = valadoc_content_content_factory_create_run (_tmp15_, VALADOC_CONTENT_RUN_STYLE_LANG_KEYWORD);
			_g_object_unref0 (_run);
			_run = _tmp16_;
			_tmp17_ = _run;
			_tmp18_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp17_);
			_tmp19_ = _tmp18_;
			_tmp20_ = self->priv->_factory;
			_tmp21_ = valadoc_content_content_factory_create_text (_tmp20_, "throws");
			_tmp22_ = _tmp21_;
			vala_collection_add ((ValaCollection*) _tmp19_, (ValadocContentInline*) _tmp22_);
			_g_object_unref0 (_tmp22_);
		} else {
			gchar* param_name = NULL;
			gchar* param_array_name = NULL;
			gboolean is_return_type_len = FALSE;
			ValadocApiTree* _tmp23_;
			ValadocApiNode* _tmp24_;
			const gchar* _tmp25_;
			const gchar* _tmp26_;
			gchar* _tmp27_ = NULL;
			gchar* _tmp28_ = NULL;
			gboolean _tmp29_ = FALSE;
			gchar* _tmp30_;
			gchar* _tmp31_;
			ValadocContentContentFactory* _tmp32_;
			ValadocContentRun* _tmp33_;
			_tmp23_ = self->priv->_tree;
			_tmp24_ = self->priv->element;
			_tmp25_ = valadoc_token_get_value (token);
			_tmp26_ = _tmp25_;
			_tmp30_ = valadoc_importer_helper_resolve_parameter_ctype (_tmp23_, _tmp24_, _tmp26_, &_tmp27_, &_tmp28_, &_tmp29_);
			_g_free0 (param_name);
			param_name = _tmp27_;
			_g_free0 (param_array_name);
			param_array_name = _tmp28_;
			is_return_type_len = _tmp29_;
			_tmp31_ = _tmp30_;
			_g_free0 (_tmp31_);
			_tmp32_ = self->priv->_factory;
			_tmp33_ = valadoc_content_content_factory_create_run (_tmp32_, VALADOC_CONTENT_RUN_STYLE_MONOSPACED);
			_g_object_unref0 (_run);
			_run = _tmp33_;
			if (is_return_type_len) {
				ValadocContentRun* keyword_run = NULL;
				ValadocContentContentFactory* _tmp34_;
				ValadocContentRun* _tmp35_;
				ValadocContentRun* _tmp36_;
				ValaList* _tmp37_;
				ValaList* _tmp38_;
				ValadocContentContentFactory* _tmp39_;
				ValadocContentText* _tmp40_;
				ValadocContentText* _tmp41_;
				ValadocContentRun* _tmp42_;
				ValaList* _tmp43_;
				ValaList* _tmp44_;
				ValadocContentRun* _tmp45_;
				ValadocContentRun* _tmp46_;
				ValaList* _tmp47_;
				ValaList* _tmp48_;
				ValadocContentContentFactory* _tmp49_;
				ValadocContentText* _tmp50_;
				ValadocContentText* _tmp51_;
				_tmp34_ = self->priv->_factory;
				_tmp35_ = valadoc_content_content_factory_create_run (_tmp34_, VALADOC_CONTENT_RUN_STYLE_LANG_KEYWORD);
				keyword_run = _tmp35_;
				_tmp36_ = keyword_run;
				_tmp37_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp36_);
				_tmp38_ = _tmp37_;
				_tmp39_ = self->priv->_factory;
				_tmp40_ = valadoc_content_content_factory_create_text (_tmp39_, "return");
				_tmp41_ = _tmp40_;
				vala_collection_add ((ValaCollection*) _tmp38_, (ValadocContentInline*) _tmp41_);
				_g_object_unref0 (_tmp41_);
				_tmp42_ = _run;
				_tmp43_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp42_);
				_tmp44_ = _tmp43_;
				_tmp45_ = keyword_run;
				vala_collection_add ((ValaCollection*) _tmp44_, (ValadocContentInline*) _tmp45_);
				_tmp46_ = _run;
				_tmp47_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp46_);
				_tmp48_ = _tmp47_;
				_tmp49_ = self->priv->_factory;
				_tmp50_ = valadoc_content_content_factory_create_text (_tmp49_, ".length");
				_tmp51_ = _tmp50_;
				vala_collection_add ((ValaCollection*) _tmp48_, (ValadocContentInline*) _tmp51_);
				_g_object_unref0 (_tmp51_);
				_g_object_unref0 (keyword_run);
			} else {
				const gchar* _tmp52_;
				_tmp52_ = param_array_name;
				if (_tmp52_ != NULL) {
					ValadocContentRun* _tmp53_;
					ValaList* _tmp54_;
					ValaList* _tmp55_;
					ValadocContentContentFactory* _tmp56_;
					const gchar* _tmp57_;
					gchar* _tmp58_;
					gchar* _tmp59_;
					ValadocContentText* _tmp60_;
					ValadocContentText* _tmp61_;
					_tmp53_ = _run;
					_tmp54_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp53_);
					_tmp55_ = _tmp54_;
					_tmp56_ = self->priv->_factory;
					_tmp57_ = param_array_name;
					_tmp58_ = g_strconcat (_tmp57_, ".length", NULL);
					_tmp59_ = _tmp58_;
					_tmp60_ = valadoc_content_content_factory_create_text (_tmp56_, _tmp59_);
					_tmp61_ = _tmp60_;
					vala_collection_add ((ValaCollection*) _tmp55_, (ValadocContentInline*) _tmp61_);
					_g_object_unref0 (_tmp61_);
					_g_free0 (_tmp59_);
				} else {
					ValadocContentRun* _tmp62_;
					ValaList* _tmp63_;
					ValaList* _tmp64_;
					ValadocContentContentFactory* _tmp65_;
					const gchar* _tmp66_;
					ValadocContentText* _tmp67_;
					ValadocContentText* _tmp68_;
					_tmp62_ = _run;
					_tmp63_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp62_);
					_tmp64_ = _tmp63_;
					_tmp65_ = self->priv->_factory;
					_tmp66_ = param_name;
					_tmp67_ = valadoc_content_content_factory_create_text (_tmp65_, _tmp66_);
					_tmp68_ = _tmp67_;
					vala_collection_add ((ValaCollection*) _tmp64_, (ValadocContentInline*) _tmp68_);
					_g_object_unref0 (_tmp68_);
				}
			}
			_g_free0 (param_array_name);
			_g_free0 (param_name);
		}
	}
	_tmp69_ = _run;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp69_);
	_g_object_unref0 (_run);
}

static void
___lambda12__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda12_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda13_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	g_return_if_fail (token != NULL);
	_tmp0_ = valadoc_token_get_value (token);
	_tmp1_ = _tmp0_;
	if (valadoc_gtkdoc_markdown_parser_is_literal (self, _tmp1_)) {
		ValadocContentRun* _run = NULL;
		ValadocContentContentFactory* _tmp2_;
		ValadocContentRun* _tmp3_;
		ValadocContentRun* _tmp4_;
		ValaList* _tmp5_;
		ValaList* _tmp6_;
		ValadocContentContentFactory* _tmp7_;
		const gchar* _tmp8_;
		const gchar* _tmp9_;
		gchar* _tmp10_;
		gchar* _tmp11_;
		ValadocContentText* _tmp12_;
		ValadocContentText* _tmp13_;
		ValadocContentRun* _tmp14_;
		_tmp2_ = self->priv->_factory;
		_tmp3_ = valadoc_content_content_factory_create_run (_tmp2_, VALADOC_CONTENT_RUN_STYLE_LANG_LITERAL);
		_run = _tmp3_;
		_tmp4_ = _run;
		_tmp5_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = self->priv->_factory;
		_tmp8_ = valadoc_token_get_value (token);
		_tmp9_ = _tmp8_;
		_tmp10_ = g_ascii_strdown (_tmp9_, (gssize) -1);
		_tmp11_ = _tmp10_;
		_tmp12_ = valadoc_content_content_factory_create_text (_tmp7_, _tmp11_);
		_tmp13_ = _tmp12_;
		vala_collection_add ((ValaCollection*) _tmp6_, (ValadocContentInline*) _tmp13_);
		_g_object_unref0 (_tmp13_);
		_g_free0 (_tmp11_);
		_tmp14_ = _run;
		valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp14_);
		_g_object_unref0 (_run);
	} else {
		const gchar* _tmp15_;
		const gchar* _tmp16_;
		gchar* _tmp17_;
		gchar* _tmp18_;
		_tmp15_ = valadoc_token_get_value (token);
		_tmp16_ = _tmp15_;
		_tmp17_ = g_strconcat ("c::", _tmp16_, NULL);
		_tmp18_ = _tmp17_;
		valadoc_gtkdoc_markdown_parser_add_symbol_link (self, _tmp18_, TRUE);
		_g_free0 (_tmp18_);
	}
}

static void
___lambda13__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda13_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda14_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	ValadocApiItem* gtype = NULL;
	ValadocApiNode* _tmp0_;
	ValadocApiItem* _tmp1_;
	gchar* parent_cname = NULL;
	ValadocApiItem* _tmp11_;
	const gchar* _tmp18_;
	gchar* _tmp19_;
	gchar* _tmp20_;
	const gchar* _tmp21_;
	const gchar* _tmp22_;
	gchar* _tmp23_;
	gchar* _tmp24_;
	g_return_if_fail (token != NULL);
	_tmp0_ = self->priv->element;
	_tmp1_ = _g_object_ref0 ((ValadocApiItem*) _tmp0_);
	gtype = _tmp1_;
	while (TRUE) {
		gboolean _tmp2_ = FALSE;
		gboolean _tmp3_ = FALSE;
		ValadocApiItem* _tmp4_;
		ValadocApiItem* _tmp7_;
		ValadocApiItem* _tmp8_;
		ValadocApiItem* _tmp9_;
		ValadocApiItem* _tmp10_;
		_tmp4_ = gtype;
		if (VALADOC_API_IS_CLASS (_tmp4_) == FALSE) {
			ValadocApiItem* _tmp5_;
			_tmp5_ = gtype;
			_tmp3_ = VALADOC_API_IS_INTERFACE (_tmp5_) == FALSE;
		} else {
			_tmp3_ = FALSE;
		}
		if (_tmp3_) {
			ValadocApiItem* _tmp6_;
			_tmp6_ = gtype;
			_tmp2_ = _tmp6_ != NULL;
		} else {
			_tmp2_ = FALSE;
		}
		if (!_tmp2_) {
			break;
		}
		_tmp7_ = gtype;
		_tmp8_ = valadoc_api_item_get_parent (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = _g_object_ref0 (_tmp9_);
		_g_object_unref0 (gtype);
		gtype = _tmp10_;
	}
	_tmp11_ = gtype;
	if (VALADOC_API_IS_CLASS (_tmp11_)) {
		ValadocApiItem* _tmp12_;
		gchar* _tmp13_;
		_tmp12_ = gtype;
		_tmp13_ = valadoc_api_class_get_cname (G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALADOC_API_TYPE_CLASS, ValadocApiClass));
		_g_free0 (parent_cname);
		parent_cname = _tmp13_;
	} else {
		ValadocApiItem* _tmp14_;
		_tmp14_ = gtype;
		if (VALADOC_API_IS_INTERFACE (_tmp14_)) {
			ValadocApiItem* _tmp15_;
			gchar* _tmp16_;
			_tmp15_ = gtype;
			_tmp16_ = valadoc_api_interface_get_cname (G_TYPE_CHECK_INSTANCE_CAST (_tmp15_, VALADOC_API_TYPE_INTERFACE, ValadocApiInterface));
			_g_free0 (parent_cname);
			parent_cname = _tmp16_;
		} else {
			gchar* _tmp17_;
			_tmp17_ = g_strdup ("");
			_g_free0 (parent_cname);
			parent_cname = _tmp17_;
		}
	}
	_tmp18_ = parent_cname;
	_tmp19_ = g_strconcat ("c::", _tmp18_, NULL);
	_tmp20_ = _tmp19_;
	_tmp21_ = valadoc_token_get_value (token);
	_tmp22_ = _tmp21_;
	_tmp23_ = g_strconcat (_tmp20_, _tmp22_, NULL);
	_tmp24_ = _tmp23_;
	valadoc_gtkdoc_markdown_parser_add_symbol_link (self, _tmp24_, TRUE);
	_g_free0 (_tmp24_);
	_g_free0 (_tmp20_);
	_g_free0 (parent_cname);
	_g_object_unref0 (gtype);
}

static void
___lambda14__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda14_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda15_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	g_return_if_fail (token != NULL);
	_tmp0_ = valadoc_token_get_value (token);
	_tmp1_ = _tmp0_;
	_tmp2_ = g_strconcat ("c::", _tmp1_, NULL);
	_tmp3_ = _tmp2_;
	valadoc_gtkdoc_markdown_parser_add_symbol_link (self, _tmp3_, TRUE);
	_g_free0 (_tmp3_);
}

static void
___lambda15__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda15_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda16_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	g_return_if_fail (token != NULL);
	_tmp0_ = valadoc_token_get_value (token);
	_tmp1_ = _tmp0_;
	_tmp2_ = g_strconcat ("c::", _tmp1_, NULL);
	_tmp3_ = _tmp2_;
	valadoc_gtkdoc_markdown_parser_add_symbol_link (self, _tmp3_, FALSE);
	_g_free0 (_tmp3_);
}

static void
___lambda16__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda16_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
_valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action (ValadocToken* token,
                                                                          gpointer self,
                                                                          GError** error)
{
	valadoc_gtkdoc_markdown_parser_preserve_token ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda17_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentLink* url = NULL;
	ValadocContentContentFactory* _tmp0_;
	ValadocContentLink* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_link (_tmp0_);
	url = _tmp1_;
	_tmp2_ = valadoc_gtkdoc_markdown_parser_pop_preserved_link (self);
	_tmp3_ = _tmp2_;
	valadoc_content_link_set_url (url, _tmp3_);
	_g_free0 (_tmp3_);
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) url);
	_g_object_unref0 (url);
}

static void
___lambda17__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda17_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda18_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocToken* _tmp0_;
	GError* _inner_error0_ = NULL;
	valadoc_gtkdoc_markdown_parser_add_content_string (self, "<");
	_tmp0_ = self->priv->preserved_token;
	valadoc_gtkdoc_markdown_parser_add_value (self, _tmp0_, &_inner_error0_);
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
			g_propagate_error (error, _inner_error0_);
			return;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return;
		}
	}
	_g_object_unref0 (self->priv->preserved_token);
	self->priv->preserved_token = NULL;
}

static void
___lambda18__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda18_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda19_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	valadoc_gtkdoc_markdown_parser_add_content_string (self, "<");
}

static void
___lambda19__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda19_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda20_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentLink* url = NULL;
	ValadocContentContentFactory* _tmp0_;
	ValadocContentLink* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	ValadocContentRun* label = NULL;
	GObject* _tmp4_;
	ValaList* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValaList* _tmp8_;
	ValaList* _tmp9_;
	ValaList* _tmp10_;
	ValaList* _tmp11_;
	ValaList* _tmp12_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_link (_tmp0_);
	url = _tmp1_;
	_tmp2_ = valadoc_gtkdoc_markdown_parser_pop_preserved_link (self);
	_tmp3_ = _tmp2_;
	valadoc_content_link_set_url (url, _tmp3_);
	_g_free0 (_tmp3_);
	_tmp4_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	label = G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp5_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) url);
	_tmp6_ = _tmp5_;
	_tmp7_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp8_ = _tmp7_;
	vala_collection_add_all ((ValaCollection*) _tmp6_, (ValaCollection*) _tmp8_);
	_tmp9_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp10_ = _tmp9_;
	vala_collection_clear ((ValaCollection*) _tmp10_);
	_tmp11_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp12_ = _tmp11_;
	vala_collection_add ((ValaCollection*) _tmp12_, (ValadocContentInline*) url);
	_g_object_unref0 (label);
	_g_object_unref0 (url);
}

static void
___lambda20__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda20_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda21_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValadocContentText* _tmp13_;
	ValadocContentText* _tmp14_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "[");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_gtkdoc_markdown_parser_pop_preserved_link (self);
	_tmp10_ = _tmp9_;
	_tmp11_ = g_strconcat ("](", _tmp10_, NULL);
	_tmp12_ = _tmp11_;
	_tmp13_ = valadoc_content_content_factory_create_text (_tmp8_, _tmp12_);
	_tmp14_ = _tmp13_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp14_);
	_g_object_unref0 (_tmp14_);
	_g_free0 (_tmp12_);
	_g_free0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda21__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda21_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda22_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	ValadocContentText* _tmp9_;
	ValadocContentText* _tmp10_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "[");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_content_content_factory_create_text (_tmp8_, "](");
	_tmp10_ = _tmp9_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp10_);
	_g_object_unref0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda22__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda22_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda23_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentLink* url = NULL;
	ValadocContentContentFactory* _tmp0_;
	ValadocContentLink* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	ValadocImporterInternalIdRegistrar* _tmp4_;
	ValadocContentRun* label = NULL;
	GObject* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValaList* _tmp8_;
	ValaList* _tmp9_;
	ValaList* _tmp10_;
	ValaList* _tmp11_;
	ValaList* _tmp12_;
	ValaList* _tmp13_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_link (_tmp0_);
	url = _tmp1_;
	_tmp2_ = valadoc_gtkdoc_markdown_parser_pop_preserved_link (self);
	_tmp3_ = _tmp2_;
	valadoc_content_link_set_url (url, _tmp3_);
	_g_free0 (_tmp3_);
	_tmp4_ = self->priv->id_registrar;
	valadoc_content_link_set_id_registrar (url, _tmp4_);
	_tmp5_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	label = G_TYPE_CHECK_INSTANCE_CAST (_tmp5_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) url);
	_tmp7_ = _tmp6_;
	_tmp8_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp9_ = _tmp8_;
	vala_collection_add_all ((ValaCollection*) _tmp7_, (ValaCollection*) _tmp9_);
	_tmp10_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp11_ = _tmp10_;
	vala_collection_clear ((ValaCollection*) _tmp11_);
	_tmp12_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp13_ = _tmp12_;
	vala_collection_add ((ValaCollection*) _tmp13_, (ValadocContentInline*) url);
	_g_object_unref0 (label);
	_g_object_unref0 (url);
}

static void
___lambda23__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda23_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda24_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValadocContentText* _tmp13_;
	ValadocContentText* _tmp14_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "[");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_gtkdoc_markdown_parser_pop_preserved_link (self);
	_tmp10_ = _tmp9_;
	_tmp11_ = g_strconcat ("][", _tmp10_, NULL);
	_tmp12_ = _tmp11_;
	_tmp13_ = valadoc_content_content_factory_create_text (_tmp8_, _tmp12_);
	_tmp14_ = _tmp13_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp14_);
	_g_object_unref0 (_tmp14_);
	_g_free0 (_tmp12_);
	_g_free0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda24__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda24_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda25_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	ValadocContentText* _tmp9_;
	ValadocContentText* _tmp10_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "[");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_content_content_factory_create_text (_tmp8_, "][");
	_tmp10_ = _tmp9_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp10_);
	_g_object_unref0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda25__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda25_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda26_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	ValadocContentText* _tmp9_;
	ValadocContentText* _tmp10_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "[");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_content_content_factory_create_text (_tmp8_, "]");
	_tmp10_ = _tmp9_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp10_);
	_g_object_unref0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda26__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda26_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda27_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "[");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_g_object_unref0 (_run);
}

static void
___lambda27__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda27_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda28_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentRun* _tmp1_;
	ValadocContentRun* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_run (_tmp0_, VALADOC_CONTENT_RUN_STYLE_NONE);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda28__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda28_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda29_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* label = NULL;
	GObject* _tmp0_;
	gchar* label_str = NULL;
	ValadocContentEmbedded* embedded = NULL;
	ValadocContentContentFactory* _tmp8_;
	ValadocContentEmbedded* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	gchar* _tmp13_;
	const gchar* _tmp14_;
	ValaList* _tmp15_;
	ValaList* _tmp16_;
	ValaList* _tmp17_;
	ValaList* _tmp18_;
	GError* _inner_error0_ = NULL;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	label = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	{
		gchar* _tmp1_ = NULL;
		gchar* _tmp2_;
		gchar* _tmp3_;
		_tmp2_ = valadoc_gtkdoc_markdown_parser_run_to_string (self, label, "<image>", &_inner_error0_);
		_tmp1_ = _tmp2_;
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			goto __catch0_g_error;
		}
		_tmp3_ = _tmp1_;
		_tmp1_ = NULL;
		_g_free0 (label_str);
		label_str = _tmp3_;
		_g_free0 (_tmp1_);
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		ValadocParser* _tmp4_;
		ValadocToken* _tmp5_;
		GError* _tmp6_;
		const gchar* _tmp7_;
		e = _inner_error0_;
		_inner_error0_ = NULL;
		_tmp4_ = self->priv->parser;
		_tmp5_ = self->priv->preserved_token;
		_tmp6_ = e;
		_tmp7_ = _tmp6_->message;
		valadoc_parser_callback_warning ((ValadocParserCallback*) _tmp4_, _tmp5_, _tmp7_);
		_g_free0 (label_str);
		label_str = NULL;
		_g_error_free0 (e);
	}
	__finally0:
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_free0 (label_str);
			_g_object_unref0 (label);
			return;
		} else {
			_g_free0 (label_str);
			_g_object_unref0 (label);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return;
		}
	}
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_content_content_factory_create_embedded (_tmp8_);
	embedded = _tmp9_;
	_tmp10_ = valadoc_gtkdoc_markdown_parser_pop_preserved_path (self);
	_tmp11_ = _tmp10_;
	_tmp12_ = valadoc_gtkdoc_markdown_parser_fix_resource_path (self, _tmp11_);
	_tmp13_ = _tmp12_;
	valadoc_content_embedded_set_url (embedded, _tmp13_);
	_g_free0 (_tmp13_);
	_g_free0 (_tmp11_);
	_tmp14_ = label_str;
	valadoc_content_embedded_set_caption (embedded, _tmp14_);
	_tmp15_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp16_ = _tmp15_;
	vala_collection_clear ((ValaCollection*) _tmp16_);
	_tmp17_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) label);
	_tmp18_ = _tmp17_;
	vala_collection_add ((ValaCollection*) _tmp18_, (ValadocContentInline*) embedded);
	_g_object_unref0 (embedded);
	_g_free0 (label_str);
	_g_object_unref0 (label);
}

static void
___lambda29__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda29_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda30_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValadocContentText* _tmp13_;
	ValadocContentText* _tmp14_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "![");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_gtkdoc_markdown_parser_pop_preserved_link (self);
	_tmp10_ = _tmp9_;
	_tmp11_ = g_strconcat ("][", _tmp10_, NULL);
	_tmp12_ = _tmp11_;
	_tmp13_ = valadoc_content_content_factory_create_text (_tmp8_, _tmp12_);
	_tmp14_ = _tmp13_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp14_);
	_g_object_unref0 (_tmp14_);
	_g_free0 (_tmp12_);
	_g_free0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda30__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda30_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda31_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	ValadocContentText* _tmp9_;
	ValadocContentText* _tmp10_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "![");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_content_content_factory_create_text (_tmp8_, "][");
	_tmp10_ = _tmp9_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp10_);
	_g_object_unref0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda31__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda31_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda32_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	ValaList* _tmp6_;
	ValaList* _tmp7_;
	ValadocContentContentFactory* _tmp8_;
	ValadocContentText* _tmp9_;
	ValadocContentText* _tmp10_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "![");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_tmp6_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp7_ = _tmp6_;
	_tmp8_ = self->priv->_factory;
	_tmp9_ = valadoc_content_content_factory_create_text (_tmp8_, "]");
	_tmp10_ = _tmp9_;
	vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentInline*) _tmp10_);
	_g_object_unref0 (_tmp10_);
	_g_object_unref0 (_run);
}

static void
___lambda32__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda32_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda33_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentRun* _run = NULL;
	GObject* _tmp0_;
	ValaList* _tmp1_;
	ValaList* _tmp2_;
	ValadocContentContentFactory* _tmp3_;
	ValadocContentText* _tmp4_;
	ValadocContentText* _tmp5_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_run = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun);
	_tmp1_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _run);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->_factory;
	_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, "!");
	_tmp5_ = _tmp4_;
	vala_list_insert (_tmp2_, 0, (ValadocContentInline*) _tmp5_);
	_g_object_unref0 (_tmp5_);
	_g_object_unref0 (_run);
}

static void
___lambda33__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda33_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda34_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentRun* _tmp1_;
	ValadocContentRun* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_run (_tmp0_, VALADOC_CONTENT_RUN_STYLE_NONE);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda34__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda34_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static ValadocContentSourceCodeLanguage*
_valadoc_content_source_code_language_dup (ValadocContentSourceCodeLanguage* self)
{
	ValadocContentSourceCodeLanguage* dup;
	dup = g_new0 (ValadocContentSourceCodeLanguage, 1);
	memcpy (dup, self, sizeof (ValadocContentSourceCodeLanguage));
	return dup;
}

static gpointer
__valadoc_content_source_code_language_dup0 (gpointer self)
{
	return self ? _valadoc_content_source_code_language_dup (self) : NULL;
}

static const gchar*
string_offset (const gchar* self,
               glong offset)
{
	const gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	result = (const gchar*) (((gchar*) self) + offset);
	return result;
}

static gint
string_index_of_char (const gchar* self,
                      gunichar c,
                      gint start_index)
{
	gchar* _result_ = NULL;
	gchar* _tmp0_;
	gchar* _tmp1_;
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	_tmp0_ = g_utf8_strchr (((gchar*) self) + start_index, (gssize) -1, c);
	_result_ = _tmp0_;
	_tmp1_ = _result_;
	if (_tmp1_ != NULL) {
		gchar* _tmp2_;
		_tmp2_ = _result_;
		result = (gint) (_tmp2_ - ((gchar*) self));
		return result;
	} else {
		result = -1;
		return result;
	}
}

static void
__lambda35_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	ValadocContentSourceCode* code = NULL;
	ValadocContentContentFactory* _tmp0_;
	ValadocContentSourceCode* _tmp1_;
	GMatchInfo* info = NULL;
	const gchar* source = NULL;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	GRegex* _tmp4_;
	const gchar* _tmp5_;
	GMatchInfo* _tmp6_ = NULL;
	gboolean _tmp7_;
	ValadocContentSourceCode* _tmp29_;
	const gchar* _tmp30_;
	ValadocContentSourceCode* _tmp31_;
	g_return_if_fail (token != NULL);
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_source_code (_tmp0_);
	code = _tmp1_;
	_tmp2_ = valadoc_token_get_value (token);
	_tmp3_ = _tmp2_;
	source = _tmp3_;
	_tmp4_ = self->priv->regex_source_lang;
	_tmp5_ = source;
	_tmp7_ = g_regex_match (_tmp4_, _tmp5_, 0, &_tmp6_);
	_g_match_info_unref0 (info);
	info = _tmp6_;
	if (_tmp7_) {
		gchar* lang_name = NULL;
		GMatchInfo* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		gchar* _tmp11_;
		gchar* _tmp12_;
		ValadocContentSourceCodeLanguage* lang = NULL;
		const gchar* _tmp13_;
		ValadocContentSourceCodeLanguage _tmp14_;
		ValadocContentSourceCodeLanguage* _tmp15_;
		ValadocContentSourceCode* _tmp16_;
		ValadocContentSourceCodeLanguage* _tmp17_;
		ValadocContentSourceCodeLanguage* _tmp18_;
		const gchar* _tmp23_;
		const gchar* _tmp24_;
		const gchar* _tmp25_;
		_tmp8_ = info;
		_tmp9_ = g_match_info_fetch (_tmp8_, 1);
		_tmp10_ = _tmp9_;
		_tmp11_ = g_ascii_strdown (_tmp10_, (gssize) -1);
		_tmp12_ = _tmp11_;
		_g_free0 (_tmp10_);
		lang_name = _tmp12_;
		_tmp13_ = lang_name;
		_tmp14_ = valadoc_content_source_code_language_from_string (_tmp13_, FALSE);
		_tmp15_ = __valadoc_content_source_code_language_dup0 (&_tmp14_);
		lang = _tmp15_;
		_tmp16_ = code;
		_tmp17_ = lang;
		valadoc_content_source_code_set_language (_tmp16_, *_tmp17_);
		_tmp18_ = lang;
		if (_tmp18_ == NULL) {
			ValadocParser* _tmp19_;
			const gchar* _tmp20_;
			gchar* _tmp21_;
			gchar* _tmp22_;
			_tmp19_ = self->priv->parser;
			_tmp20_ = lang_name;
			_tmp21_ = g_strdup_printf ("Unknown language `%s' in source code block |[<!-- language=\"\"", _tmp20_);
			_tmp22_ = _tmp21_;
			valadoc_parser_callback_warning ((ValadocParserCallback*) _tmp19_, token, _tmp22_);
			_g_free0 (_tmp22_);
		}
		_tmp23_ = source;
		_tmp24_ = source;
		_tmp25_ = string_offset (_tmp23_, (glong) (string_index_of_char (_tmp24_, (gunichar) '>', 0) + 1));
		source = _tmp25_;
		_g_free0 (lang);
		_g_free0 (lang_name);
	} else {
		ValadocContentSourceCodeLanguage _tmp26_ = 0;
		const gchar* _tmp27_;
		ValadocContentSourceCode* _tmp28_;
		_tmp27_ = source;
		if (valadoc_highlighter_xml_scanner_is_xml (_tmp27_)) {
			_tmp26_ = VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_XML;
		} else {
			_tmp26_ = VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_C;
		}
		_tmp28_ = code;
		valadoc_content_source_code_set_language (_tmp28_, _tmp26_);
	}
	_tmp29_ = code;
	_tmp30_ = source;
	valadoc_content_source_code_set_code (_tmp29_, _tmp30_);
	_tmp31_ = code;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp31_);
	_g_match_info_unref0 (info);
	_g_object_unref0 (code);
}

static void
___lambda35__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda35_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
_valadoc_gtkdoc_markdown_parser_add_value_valadoc_token_type_action (ValadocToken* token,
                                                                     gpointer self,
                                                                     GError** error)
{
	valadoc_gtkdoc_markdown_parser_add_value ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda36_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentText* _tmp1_;
	ValadocContentText* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_text (_tmp0_, NULL);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda36__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda36_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda37_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentInline* head = NULL;
	GObject* _tmp0_;
	GObject* _tmp1_;
	ValadocContentInlineContent* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	head = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_INLINE, ValadocContentInline);
	_tmp1_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp2_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALADOC_CONTENT_TYPE_INLINE_CONTENT, ValadocContentInlineContent);
	_tmp3_ = valadoc_content_inline_content_get_content (_tmp2_);
	_tmp4_ = _tmp3_;
	vala_collection_add ((ValaCollection*) _tmp4_, head);
	_g_object_unref0 (_tmp2_);
	_g_object_unref0 (head);
}

static void
___lambda37__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda37_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda38_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentListItem* _tmp1_;
	ValadocContentListItem* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_list_item (_tmp0_);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda38__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda38_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda39_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentListItem* head = NULL;
	GObject* _tmp0_;
	GObject* _tmp1_;
	ValadocContentList* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	head = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_LIST_ITEM, ValadocContentListItem);
	_tmp1_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp2_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALADOC_CONTENT_TYPE_LIST, ValadocContentList);
	_tmp3_ = valadoc_content_list_get_items (_tmp2_);
	_tmp4_ = _tmp3_;
	vala_collection_add ((ValaCollection*) _tmp4_, head);
	_g_object_unref0 (_tmp2_);
	_g_object_unref0 (head);
}

static void
___lambda39__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda39_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static gpointer
_vala_iterable_ref0 (gpointer self)
{
	return self ? vala_iterable_ref (self) : NULL;
}

static void
__lambda40_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValaList* siblings = NULL;
	GObject* _tmp0_;
	ValadocContentBlockContent* _tmp1_;
	ValaList* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	ValaList* _tmp5_;
	gboolean _tmp6_ = FALSE;
	ValaList* _tmp7_;
	gint _tmp8_;
	gint _tmp9_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp1_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_BLOCK_CONTENT, ValadocContentBlockContent);
	_tmp2_ = valadoc_content_block_content_get_content (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = _vala_iterable_ref0 (_tmp3_);
	_tmp5_ = _tmp4_;
	_g_object_unref0 (_tmp1_);
	siblings = _tmp5_;
	_tmp7_ = siblings;
	_tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
	_tmp9_ = _tmp8_;
	if (_tmp9_ > 0) {
		ValaList* _tmp10_;
		gpointer _tmp11_;
		ValadocContentBlock* _tmp12_;
		_tmp10_ = siblings;
		_tmp11_ = vala_list_last (_tmp10_);
		_tmp12_ = (ValadocContentBlock*) _tmp11_;
		_tmp6_ = VALADOC_CONTENT_IS_LIST (_tmp12_);
		_g_object_unref0 (_tmp12_);
	} else {
		_tmp6_ = FALSE;
	}
	if (_tmp6_) {
		ValaList* _tmp13_;
		gpointer _tmp14_;
		ValadocContentBlock* _tmp15_;
		_tmp13_ = siblings;
		_tmp14_ = vala_list_last (_tmp13_);
		_tmp15_ = (ValadocContentBlock*) _tmp14_;
		valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp15_);
		_g_object_unref0 (_tmp15_);
	} else {
		ValadocContentList* list = NULL;
		ValadocContentContentFactory* _tmp16_;
		ValadocContentList* _tmp17_;
		ValadocContentList* _tmp18_;
		ValaList* _tmp19_;
		ValadocContentList* _tmp20_;
		ValadocContentList* _tmp21_;
		_tmp16_ = self->priv->_factory;
		_tmp17_ = valadoc_content_content_factory_create_list (_tmp16_);
		list = _tmp17_;
		_tmp18_ = list;
		valadoc_content_list_set_bullet (_tmp18_, VALADOC_CONTENT_LIST_BULLET_UNORDERED);
		_tmp19_ = siblings;
		_tmp20_ = list;
		vala_collection_add ((ValaCollection*) _tmp19_, (ValadocContentBlock*) _tmp20_);
		_tmp21_ = list;
		valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp21_);
		_g_object_unref0 (list);
	}
	_vala_iterable_unref0 (siblings);
}

static void
___lambda40__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda40_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda41_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	GObject* _tmp0_;
	GObject* _tmp1_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_tmp1_);
}

static void
___lambda41__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda41_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda42_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentListItem* _tmp1_;
	ValadocContentListItem* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_list_item (_tmp0_);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda42__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda42_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda43_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentListItem* head = NULL;
	GObject* _tmp0_;
	GObject* _tmp1_;
	ValadocContentList* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	head = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_LIST_ITEM, ValadocContentListItem);
	_tmp1_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp2_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALADOC_CONTENT_TYPE_LIST, ValadocContentList);
	_tmp3_ = valadoc_content_list_get_items (_tmp2_);
	_tmp4_ = _tmp3_;
	vala_collection_add ((ValaCollection*) _tmp4_, head);
	_g_object_unref0 (_tmp2_);
	_g_object_unref0 (head);
}

static void
___lambda43__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda43_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda44_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValaList* siblings = NULL;
	GObject* _tmp0_;
	ValadocContentBlockContent* _tmp1_;
	ValaList* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	ValaList* _tmp5_;
	gboolean _tmp6_ = FALSE;
	ValaList* _tmp7_;
	gint _tmp8_;
	gint _tmp9_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp1_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_BLOCK_CONTENT, ValadocContentBlockContent);
	_tmp2_ = valadoc_content_block_content_get_content (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = _vala_iterable_ref0 (_tmp3_);
	_tmp5_ = _tmp4_;
	_g_object_unref0 (_tmp1_);
	siblings = _tmp5_;
	_tmp7_ = siblings;
	_tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
	_tmp9_ = _tmp8_;
	if (_tmp9_ > 0) {
		ValaList* _tmp10_;
		gpointer _tmp11_;
		ValadocContentBlock* _tmp12_;
		_tmp10_ = siblings;
		_tmp11_ = vala_list_last (_tmp10_);
		_tmp12_ = (ValadocContentBlock*) _tmp11_;
		_tmp6_ = VALADOC_CONTENT_IS_LIST (_tmp12_);
		_g_object_unref0 (_tmp12_);
	} else {
		_tmp6_ = FALSE;
	}
	if (_tmp6_) {
		ValaList* _tmp13_;
		gpointer _tmp14_;
		ValadocContentBlock* _tmp15_;
		_tmp13_ = siblings;
		_tmp14_ = vala_list_last (_tmp13_);
		_tmp15_ = (ValadocContentBlock*) _tmp14_;
		valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp15_);
		_g_object_unref0 (_tmp15_);
	} else {
		ValadocContentList* list = NULL;
		ValadocContentContentFactory* _tmp16_;
		ValadocContentList* _tmp17_;
		ValadocContentList* _tmp18_;
		ValaList* _tmp19_;
		ValadocContentList* _tmp20_;
		ValadocContentList* _tmp21_;
		_tmp16_ = self->priv->_factory;
		_tmp17_ = valadoc_content_content_factory_create_list (_tmp16_);
		list = _tmp17_;
		_tmp18_ = list;
		valadoc_content_list_set_bullet (_tmp18_, VALADOC_CONTENT_LIST_BULLET_ORDERED_NUMBER);
		_tmp19_ = siblings;
		_tmp20_ = list;
		vala_collection_add ((ValaCollection*) _tmp19_, (ValadocContentBlock*) _tmp20_);
		_tmp21_ = list;
		valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp21_);
		_g_object_unref0 (list);
	}
	_vala_iterable_unref0 (siblings);
}

static void
___lambda44__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda44_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda45_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	GObject* _tmp0_;
	GObject* _tmp1_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_tmp1_);
}

static void
___lambda45__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda45_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda46_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentParagraph* _tmp1_;
	ValadocContentParagraph* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_paragraph (_tmp0_);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda46__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda46_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda47_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentParagraph* head = NULL;
	GObject* _tmp0_;
	GObject* _tmp1_;
	ValadocContentBlockContent* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	head = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_PARAGRAPH, ValadocContentParagraph);
	_tmp1_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp2_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALADOC_CONTENT_TYPE_BLOCK_CONTENT, ValadocContentBlockContent);
	_tmp3_ = valadoc_content_block_content_get_content (_tmp2_);
	_tmp4_ = _tmp3_;
	vala_collection_add ((ValaCollection*) _tmp4_, (ValadocContentBlock*) head);
	_g_object_unref0 (_tmp2_);
	_g_object_unref0 (head);
}

static void
___lambda47__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda47_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda48_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentNote* _tmp1_;
	ValadocContentNote* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_note (_tmp0_);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda48__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda48_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda49_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentNote* head = NULL;
	GObject* _tmp0_;
	GObject* _tmp1_;
	ValadocContentBlockContent* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	head = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_NOTE, ValadocContentNote);
	_tmp1_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp2_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALADOC_CONTENT_TYPE_BLOCK_CONTENT, ValadocContentBlockContent);
	_tmp3_ = valadoc_content_block_content_get_content (_tmp2_);
	_tmp4_ = _tmp3_;
	vala_collection_add ((ValaCollection*) _tmp4_, (ValadocContentBlock*) head);
	_g_object_unref0 (_tmp2_);
	_g_object_unref0 (head);
}

static void
___lambda49__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda49_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda50_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	ValadocContentHeadline* h = NULL;
	GObject* _tmp0_;
	g_return_if_fail (token != NULL);
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	h = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_HEADLINE, ValadocContentHeadline);
	valadoc_content_headline_set_level (h, 1);
	_g_object_unref0 (h);
}

static void
___lambda50__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda50_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda51_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	ValadocContentHeadline* h = NULL;
	GObject* _tmp0_;
	g_return_if_fail (token != NULL);
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	h = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_HEADLINE, ValadocContentHeadline);
	valadoc_content_headline_set_level (h, 2);
	_g_object_unref0 (h);
}

static void
___lambda51__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda51_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda52_ (ValadocGtkdocMarkdownParser* self,
             ValadocToken* token,
             GError** error)
{
	ValadocImporterInternalIdRegistrar* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	ValadocApiNode* _tmp3_;
	g_return_if_fail (token != NULL);
	_tmp0_ = self->priv->id_registrar;
	_tmp1_ = valadoc_token_get_value (token);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->element;
	valadoc_importer_internal_id_registrar_register_symbol (_tmp0_, _tmp2_, _tmp3_);
}

static void
___lambda52__valadoc_token_type_action (ValadocToken* token,
                                        gpointer self,
                                        GError** error)
{
	__lambda52_ ((ValadocGtkdocMarkdownParser*) self, token, error);
}

static void
__lambda53_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentHeadline* _tmp1_;
	ValadocContentHeadline* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_headline (_tmp0_);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda53__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda53_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda54_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentHeadline* h = NULL;
	GObject* _tmp0_;
	GObject* _tmp1_;
	ValadocContentBlockContent* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	_tmp0_ = valadoc_gtkdoc_markdown_parser_pop (self);
	h = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALADOC_CONTENT_TYPE_HEADLINE, ValadocContentHeadline);
	_tmp1_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp2_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALADOC_CONTENT_TYPE_BLOCK_CONTENT, ValadocContentBlockContent);
	_tmp3_ = valadoc_content_block_content_get_content (_tmp2_);
	_tmp4_ = _tmp3_;
	vala_collection_add ((ValaCollection*) _tmp4_, (ValadocContentBlock*) h);
	_g_object_unref0 (_tmp2_);
	_g_object_unref0 (h);
}

static void
___lambda54__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda54_ ((ValadocGtkdocMarkdownParser*) self, error);
}

static void
__lambda55_ (ValadocGtkdocMarkdownParser* self,
             GError** error)
{
	ValadocContentContentFactory* _tmp0_;
	ValadocContentComment* _tmp1_;
	ValadocContentComment* _tmp2_;
	_tmp0_ = self->priv->_factory;
	_tmp1_ = valadoc_content_content_factory_create_comment (_tmp0_);
	_tmp2_ = _tmp1_;
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
}

static void
___lambda55__valadoc_rule_action (gpointer self,
                                  GError** error)
{
	__lambda55_ ((ValadocGtkdocMarkdownParser*) self, error);
}

void
valadoc_gtkdoc_markdown_parser_init_rules (ValadocGtkdocMarkdownParser* self)
{
	ValadocTokenType* word = NULL;
	ValadocTokenType* _tmp0_;
	ValadocTokenType* _tmp1_;
	ValadocTokenType* _tmp2_;
	ValadocTokenType* _tmp3_;
	ValadocStubRule* content = NULL;
	ValadocStubRule* _tmp4_;
	ValadocRule* _tmp5_;
	ValadocRule* _tmp6_;
	ValadocStubRule* run = NULL;
	ValadocStubRule* _tmp7_;
	ValadocRule* _tmp8_;
	ValadocRule* _tmp9_;
	ValadocRule* param = NULL;
	ValadocTokenType* _tmp10_;
	ValadocTokenType* _tmp11_;
	GObject** _tmp12_;
	GObject** _tmp13_;
	gint _tmp13__length1;
	ValadocRule* _tmp14_;
	ValadocRule* _tmp15_;
	ValadocRule* _tmp16_;
	ValadocRule* _tmp17_;
	ValadocRule* constant = NULL;
	ValadocTokenType* _tmp18_;
	ValadocTokenType* _tmp19_;
	GObject** _tmp20_;
	GObject** _tmp21_;
	gint _tmp21__length1;
	ValadocRule* _tmp22_;
	ValadocRule* _tmp23_;
	ValadocRule* _tmp24_;
	ValadocRule* _tmp25_;
	ValadocRule* gmember = NULL;
	ValadocTokenType* _tmp26_;
	ValadocTokenType* _tmp27_;
	GObject** _tmp28_;
	GObject** _tmp29_;
	gint _tmp29__length1;
	ValadocRule* _tmp30_;
	ValadocRule* _tmp31_;
	ValadocRule* _tmp32_;
	ValadocRule* _tmp33_;
	ValadocRule* symbol = NULL;
	ValadocTokenType* _tmp34_;
	ValadocTokenType* _tmp35_;
	GObject** _tmp36_;
	GObject** _tmp37_;
	gint _tmp37__length1;
	ValadocRule* _tmp38_;
	ValadocRule* _tmp39_;
	ValadocRule* _tmp40_;
	ValadocRule* _tmp41_;
	ValadocRule* function = NULL;
	ValadocTokenType* _tmp42_;
	ValadocTokenType* _tmp43_;
	GObject** _tmp44_;
	GObject** _tmp45_;
	gint _tmp45__length1;
	ValadocRule* _tmp46_;
	ValadocRule* _tmp47_;
	ValadocRule* _tmp48_;
	ValadocRule* _tmp49_;
	ValadocRule* link_short = NULL;
	ValadocTokenType* _tmp50_;
	GObject* _tmp51_;
	ValadocTokenType* _tmp52_;
	ValadocTokenType* _tmp53_;
	ValadocTokenType* _tmp54_;
	ValadocTokenType* _tmp55_;
	GObject** _tmp56_;
	GObject** _tmp57_;
	gint _tmp57__length1;
	ValadocRule* _tmp58_;
	ValadocTokenType* _tmp59_;
	GObject* _tmp60_;
	GObject** _tmp61_;
	GObject** _tmp62_;
	gint _tmp62__length1;
	ValadocRule* _tmp63_;
	ValadocRule* _tmp64_;
	ValadocRule* _tmp65_;
	ValadocRule* _tmp66_;
	ValadocRule* _tmp67_;
	GObject** _tmp68_;
	GObject** _tmp69_;
	gint _tmp69__length1;
	ValadocRule* _tmp70_;
	ValadocRule* _tmp71_;
	ValadocRule* _tmp72_;
	GObject** _tmp73_;
	GObject** _tmp74_;
	gint _tmp74__length1;
	ValadocRule* _tmp75_;
	ValadocRule* _tmp76_;
	ValadocRule* _tmp77_;
	ValadocRule* _tmp78_;
	ValadocRule* link = NULL;
	ValadocTokenType* _tmp79_;
	GObject* _tmp80_;
	GObject* _tmp81_;
	GObject** _tmp82_;
	GObject** _tmp83_;
	gint _tmp83__length1;
	ValadocRule* _tmp84_;
	ValadocTokenType* _tmp85_;
	GObject* _tmp86_;
	ValadocTokenType* _tmp87_;
	GObject* _tmp88_;
	ValadocTokenType* _tmp89_;
	ValadocTokenType* _tmp90_;
	ValadocTokenType* _tmp91_;
	ValadocTokenType* _tmp92_;
	GObject** _tmp93_;
	GObject** _tmp94_;
	gint _tmp94__length1;
	ValadocRule* _tmp95_;
	ValadocTokenType* _tmp96_;
	GObject* _tmp97_;
	GObject** _tmp98_;
	GObject** _tmp99_;
	gint _tmp99__length1;
	ValadocRule* _tmp100_;
	ValadocRule* _tmp101_;
	ValadocRule* _tmp102_;
	ValadocRule* _tmp103_;
	ValadocRule* _tmp104_;
	GObject** _tmp105_;
	GObject** _tmp106_;
	gint _tmp106__length1;
	ValadocRule* _tmp107_;
	ValadocRule* _tmp108_;
	ValadocRule* _tmp109_;
	GObject** _tmp110_;
	GObject** _tmp111_;
	gint _tmp111__length1;
	ValadocRule* _tmp112_;
	ValadocTokenType* _tmp113_;
	GObject* _tmp114_;
	ValadocTokenType* _tmp115_;
	ValadocTokenType* _tmp116_;
	ValadocTokenType* _tmp117_;
	ValadocTokenType* _tmp118_;
	GObject* _tmp119_;
	GObject** _tmp120_;
	GObject** _tmp121_;
	gint _tmp121__length1;
	ValadocRule* _tmp122_;
	ValadocRule* _tmp123_;
	ValadocRule* _tmp124_;
	ValadocRule* _tmp125_;
	ValadocRule* _tmp126_;
	GObject** _tmp127_;
	GObject** _tmp128_;
	gint _tmp128__length1;
	ValadocRule* _tmp129_;
	ValadocRule* _tmp130_;
	ValadocRule* _tmp131_;
	GObject** _tmp132_;
	GObject** _tmp133_;
	gint _tmp133__length1;
	ValadocRule* _tmp134_;
	GObject** _tmp135_;
	GObject** _tmp136_;
	gint _tmp136__length1;
	ValadocRule* _tmp137_;
	GObject** _tmp138_;
	GObject** _tmp139_;
	gint _tmp139__length1;
	ValadocRule* _tmp140_;
	ValadocRule* _tmp141_;
	ValadocRule* _tmp142_;
	GObject** _tmp143_;
	GObject** _tmp144_;
	gint _tmp144__length1;
	ValadocRule* _tmp145_;
	ValadocRule* _tmp146_;
	ValadocRule* _tmp147_;
	GObject** _tmp148_;
	GObject** _tmp149_;
	gint _tmp149__length1;
	ValadocRule* _tmp150_;
	ValadocRule* _tmp151_;
	ValadocRule* _tmp152_;
	ValadocRule* _tmp153_;
	ValadocRule* _tmp154_;
	ValadocRule* _tmp155_;
	ValadocRule* image = NULL;
	ValadocTokenType* _tmp156_;
	GObject* _tmp157_;
	ValadocTokenType* _tmp158_;
	GObject* _tmp159_;
	GObject* _tmp160_;
	GObject** _tmp161_;
	GObject** _tmp162_;
	gint _tmp162__length1;
	ValadocRule* _tmp163_;
	ValadocTokenType* _tmp164_;
	GObject* _tmp165_;
	ValadocTokenType* _tmp166_;
	GObject* _tmp167_;
	ValadocTokenType* _tmp168_;
	ValadocTokenType* _tmp169_;
	ValadocTokenType* _tmp170_;
	ValadocTokenType* _tmp171_;
	ValadocTokenType* _tmp172_;
	ValadocTokenType* _tmp173_;
	ValadocTokenType* _tmp174_;
	GObject** _tmp175_;
	GObject** _tmp176_;
	gint _tmp176__length1;
	ValadocRule* _tmp177_;
	ValadocTokenType* _tmp178_;
	GObject* _tmp179_;
	GObject** _tmp180_;
	GObject** _tmp181_;
	gint _tmp181__length1;
	ValadocRule* _tmp182_;
	ValadocRule* _tmp183_;
	ValadocRule* _tmp184_;
	ValadocRule* _tmp185_;
	ValadocRule* _tmp186_;
	GObject** _tmp187_;
	GObject** _tmp188_;
	gint _tmp188__length1;
	ValadocRule* _tmp189_;
	ValadocRule* _tmp190_;
	ValadocRule* _tmp191_;
	GObject** _tmp192_;
	GObject** _tmp193_;
	gint _tmp193__length1;
	ValadocRule* _tmp194_;
	ValadocRule* _tmp195_;
	ValadocRule* _tmp196_;
	GObject** _tmp197_;
	GObject** _tmp198_;
	gint _tmp198__length1;
	ValadocRule* _tmp199_;
	ValadocRule* _tmp200_;
	ValadocRule* _tmp201_;
	GObject** _tmp202_;
	GObject** _tmp203_;
	gint _tmp203__length1;
	ValadocRule* _tmp204_;
	ValadocRule* _tmp205_;
	ValadocRule* _tmp206_;
	ValadocRule* _tmp207_;
	ValadocRule* _tmp208_;
	ValadocRule* _tmp209_;
	ValadocRule* source = NULL;
	ValadocTokenType* _tmp210_;
	ValadocTokenType* _tmp211_;
	GObject** _tmp212_;
	GObject** _tmp213_;
	gint _tmp213__length1;
	ValadocRule* _tmp214_;
	ValadocRule* _tmp215_;
	ValadocRule* _tmp216_;
	ValadocRule* _tmp217_;
	ValadocRule* text = NULL;
	GObject* _tmp218_;
	ValadocTokenType* _tmp219_;
	ValadocTokenType* _tmp220_;
	ValadocTokenType* _tmp221_;
	ValadocTokenType* _tmp222_;
	ValadocTokenType* _tmp223_;
	ValadocTokenType* _tmp224_;
	ValadocTokenType* _tmp225_;
	ValadocTokenType* _tmp226_;
	ValadocTokenType* _tmp227_;
	ValadocTokenType* _tmp228_;
	ValadocTokenType* _tmp229_;
	ValadocTokenType* _tmp230_;
	ValadocTokenType* _tmp231_;
	ValadocTokenType* _tmp232_;
	GObject** _tmp233_;
	GObject** _tmp234_;
	gint _tmp234__length1;
	ValadocRule* _tmp235_;
	GObject** _tmp236_;
	GObject** _tmp237_;
	gint _tmp237__length1;
	ValadocRule* _tmp238_;
	ValadocRule* _tmp239_;
	ValadocRule* _tmp240_;
	ValadocRule* _tmp241_;
	ValadocRule* _tmp242_;
	ValadocRule* _tmp243_;
	GObject* _tmp244_;
	GObject* _tmp245_;
	GObject* _tmp246_;
	GObject* _tmp247_;
	GObject* _tmp248_;
	GObject* _tmp249_;
	GObject* _tmp250_;
	GObject* _tmp251_;
	GObject* _tmp252_;
	GObject* _tmp253_;
	GObject** _tmp254_;
	GObject** _tmp255_;
	gint _tmp255__length1;
	ValadocRule* _tmp256_;
	ValadocRule* _tmp257_;
	ValadocRule* _tmp258_;
	GObject** _tmp259_;
	GObject** _tmp260_;
	gint _tmp260__length1;
	ValadocRule* _tmp261_;
	ValadocRule* _tmp262_;
	ValadocRule* _tmp263_;
	ValadocRule* _tmp264_;
	ValadocRule* unordered_list = NULL;
	ValadocTokenType* _tmp265_;
	GObject* _tmp266_;
	GObject* _tmp267_;
	ValadocTokenType* _tmp268_;
	GObject* _tmp269_;
	GObject** _tmp270_;
	GObject** _tmp271_;
	gint _tmp271__length1;
	ValadocRule* _tmp272_;
	ValadocRule* _tmp273_;
	ValadocRule* _tmp274_;
	ValadocRule* _tmp275_;
	ValadocRule* _tmp276_;
	GObject** _tmp277_;
	GObject** _tmp278_;
	gint _tmp278__length1;
	ValadocRule* _tmp279_;
	ValadocRule* _tmp280_;
	ValadocRule* _tmp281_;
	ValadocRule* _tmp282_;
	ValadocRule* _tmp283_;
	ValadocRule* _tmp284_;
	ValadocRule* _tmp285_;
	ValadocRule* _tmp286_;
	ValadocRule* ordered_list = NULL;
	ValadocTokenType* _tmp287_;
	GObject* _tmp288_;
	GObject* _tmp289_;
	ValadocTokenType* _tmp290_;
	GObject* _tmp291_;
	GObject** _tmp292_;
	GObject** _tmp293_;
	gint _tmp293__length1;
	ValadocRule* _tmp294_;
	ValadocRule* _tmp295_;
	ValadocRule* _tmp296_;
	ValadocRule* _tmp297_;
	ValadocRule* _tmp298_;
	GObject** _tmp299_;
	GObject** _tmp300_;
	gint _tmp300__length1;
	ValadocRule* _tmp301_;
	ValadocRule* _tmp302_;
	ValadocRule* _tmp303_;
	ValadocRule* _tmp304_;
	ValadocRule* _tmp305_;
	ValadocRule* _tmp306_;
	ValadocRule* _tmp307_;
	ValadocRule* _tmp308_;
	ValadocRule* paragraph = NULL;
	ValadocTokenType* _tmp309_;
	GObject* _tmp310_;
	ValadocTokenType* _tmp311_;
	GObject* _tmp312_;
	GObject** _tmp313_;
	GObject** _tmp314_;
	gint _tmp314__length1;
	ValadocRule* _tmp315_;
	GObject* _tmp316_;
	GObject** _tmp317_;
	GObject** _tmp318_;
	gint _tmp318__length1;
	ValadocRule* _tmp319_;
	GObject** _tmp320_;
	GObject** _tmp321_;
	gint _tmp321__length1;
	ValadocRule* _tmp322_;
	ValadocRule* _tmp323_;
	ValadocRule* _tmp324_;
	ValadocRule* _tmp325_;
	ValadocRule* _tmp326_;
	ValadocRule* _tmp327_;
	ValadocRule* _tmp328_;
	ValadocRule* _tmp329_;
	ValadocRule* block = NULL;
	ValadocTokenType* _tmp330_;
	GObject* _tmp331_;
	GObject* _tmp332_;
	ValadocTokenType* _tmp333_;
	GObject* _tmp334_;
	GObject** _tmp335_;
	GObject** _tmp336_;
	gint _tmp336__length1;
	ValadocRule* _tmp337_;
	ValadocRule* _tmp338_;
	ValadocRule* _tmp339_;
	ValadocRule* _tmp340_;
	ValadocRule* _tmp341_;
	ValadocRule* _tmp342_;
	ValadocRule* _tmp343_;
	ValadocRule* _tmp344_;
	ValadocRule* headline = NULL;
	ValadocTokenType* _tmp345_;
	ValadocTokenType* _tmp346_;
	ValadocTokenType* _tmp347_;
	ValadocTokenType* _tmp348_;
	GObject** _tmp349_;
	GObject** _tmp350_;
	gint _tmp350__length1;
	ValadocRule* _tmp351_;
	GObject* _tmp352_;
	ValadocTokenType* _tmp353_;
	ValadocTokenType* _tmp354_;
	GObject** _tmp355_;
	GObject** _tmp356_;
	gint _tmp356__length1;
	ValadocRule* _tmp357_;
	ValadocTokenType* _tmp358_;
	GObject* _tmp359_;
	GObject** _tmp360_;
	GObject** _tmp361_;
	gint _tmp361__length1;
	ValadocRule* _tmp362_;
	ValadocRule* _tmp363_;
	ValadocRule* _tmp364_;
	ValadocRule* _tmp365_;
	ValadocRule* _tmp366_;
	ValadocRule* _tmp367_;
	ValadocRule* _tmp368_;
	ValadocRule* _tmp369_;
	GObject* _tmp370_;
	GObject* _tmp371_;
	GObject* _tmp372_;
	GObject* _tmp373_;
	GObject* _tmp374_;
	GObject** _tmp375_;
	GObject** _tmp376_;
	gint _tmp376__length1;
	ValadocRule* _tmp377_;
	GObject** _tmp378_;
	GObject** _tmp379_;
	gint _tmp379__length1;
	ValadocRule* _tmp380_;
	ValadocRule* _tmp381_;
	ValadocRule* _tmp382_;
	ValadocRule* _tmp383_;
	ValadocRule* comment = NULL;
	GObject* _tmp384_;
	ValadocTokenType* _tmp385_;
	GObject* _tmp386_;
	GObject** _tmp387_;
	GObject** _tmp388_;
	gint _tmp388__length1;
	ValadocRule* _tmp389_;
	ValadocRule* _tmp390_;
	ValadocRule* _tmp391_;
	ValadocRule* _tmp392_;
	ValadocRule* _tmp393_;
	ValadocRule* _tmp394_;
	ValadocParser* _tmp395_;
	g_return_if_fail (self != NULL);
	_tmp0_ = valadoc_token_type_any_word ();
	_tmp1_ = _tmp0_;
	_tmp2_ = valadoc_token_type_action (_tmp1_, _valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action, self);
	_tmp3_ = _tmp2_;
	_g_object_unref0 (_tmp1_);
	word = _tmp3_;
	_tmp4_ = valadoc_stub_rule_new ();
	content = _tmp4_;
	_tmp5_ = valadoc_rule_set_name ((ValadocRule*) content, "Content");
	_tmp6_ = _tmp5_;
	_g_object_unref0 (_tmp6_);
	_tmp7_ = valadoc_stub_rule_new ();
	run = _tmp7_;
	_tmp8_ = valadoc_rule_set_name ((ValadocRule*) run, "Run");
	_tmp9_ = _tmp8_;
	_g_object_unref0 (_tmp9_);
	_tmp10_ = valadoc_token_type_MARKDOWN_PARAMETER;
	_tmp11_ = valadoc_token_type_action (_tmp10_, ___lambda12__valadoc_token_type_action, self);
	_tmp12_ = g_new0 (GObject*, 1 + 1);
	_tmp12_[0] = (GObject*) _tmp11_;
	_tmp13_ = _tmp12_;
	_tmp13__length1 = 1;
	_tmp14_ = valadoc_rule_seq (_tmp13_, (gint) 1);
	_tmp15_ = _tmp14_;
	_tmp16_ = valadoc_rule_set_name (_tmp15_, "Parameter");
	_tmp17_ = _tmp16_;
	_g_object_unref0 (_tmp15_);
	_tmp13_ = (_vala_array_free (_tmp13_, _tmp13__length1, (GDestroyNotify) g_object_unref), NULL);
	param = _tmp17_;
	_tmp18_ = valadoc_token_type_MARKDOWN_CONSTANT;
	_tmp19_ = valadoc_token_type_action (_tmp18_, ___lambda13__valadoc_token_type_action, self);
	_tmp20_ = g_new0 (GObject*, 1 + 1);
	_tmp20_[0] = (GObject*) _tmp19_;
	_tmp21_ = _tmp20_;
	_tmp21__length1 = 1;
	_tmp22_ = valadoc_rule_seq (_tmp21_, (gint) 1);
	_tmp23_ = _tmp22_;
	_tmp24_ = valadoc_rule_set_name (_tmp23_, "Constant");
	_tmp25_ = _tmp24_;
	_g_object_unref0 (_tmp23_);
	_tmp21_ = (_vala_array_free (_tmp21_, _tmp21__length1, (GDestroyNotify) g_object_unref), NULL);
	constant = _tmp25_;
	_tmp26_ = valadoc_token_type_MARKDOWN_LOCAL_GMEMBER;
	_tmp27_ = valadoc_token_type_action (_tmp26_, ___lambda14__valadoc_token_type_action, self);
	_tmp28_ = g_new0 (GObject*, 1 + 1);
	_tmp28_[0] = (GObject*) _tmp27_;
	_tmp29_ = _tmp28_;
	_tmp29__length1 = 1;
	_tmp30_ = valadoc_rule_seq (_tmp29_, (gint) 1);
	_tmp31_ = _tmp30_;
	_tmp32_ = valadoc_rule_set_name (_tmp31_, "GLocalMember");
	_tmp33_ = _tmp32_;
	_g_object_unref0 (_tmp31_);
	_tmp29_ = (_vala_array_free (_tmp29_, _tmp29__length1, (GDestroyNotify) g_object_unref), NULL);
	gmember = _tmp33_;
	_tmp34_ = valadoc_token_type_MARKDOWN_SYMBOL;
	_tmp35_ = valadoc_token_type_action (_tmp34_, ___lambda15__valadoc_token_type_action, self);
	_tmp36_ = g_new0 (GObject*, 1 + 1);
	_tmp36_[0] = (GObject*) _tmp35_;
	_tmp37_ = _tmp36_;
	_tmp37__length1 = 1;
	_tmp38_ = valadoc_rule_seq (_tmp37_, (gint) 1);
	_tmp39_ = _tmp38_;
	_tmp40_ = valadoc_rule_set_name (_tmp39_, "Symbol");
	_tmp41_ = _tmp40_;
	_g_object_unref0 (_tmp39_);
	_tmp37_ = (_vala_array_free (_tmp37_, _tmp37__length1, (GDestroyNotify) g_object_unref), NULL);
	symbol = _tmp41_;
	_tmp42_ = valadoc_token_type_MARKDOWN_FUNCTION;
	_tmp43_ = valadoc_token_type_action (_tmp42_, ___lambda16__valadoc_token_type_action, self);
	_tmp44_ = g_new0 (GObject*, 1 + 1);
	_tmp44_[0] = (GObject*) _tmp43_;
	_tmp45_ = _tmp44_;
	_tmp45__length1 = 1;
	_tmp46_ = valadoc_rule_seq (_tmp45_, (gint) 1);
	_tmp47_ = _tmp46_;
	_tmp48_ = valadoc_rule_set_name (_tmp47_, "Function");
	_tmp49_ = _tmp48_;
	_g_object_unref0 (_tmp47_);
	_tmp45_ = (_vala_array_free (_tmp45_, _tmp45__length1, (GDestroyNotify) g_object_unref), NULL);
	function = _tmp49_;
	_tmp50_ = valadoc_token_type_MARKDOWN_LESS_THAN;
	_tmp51_ = _g_object_ref0 ((GObject*) _tmp50_);
	_tmp52_ = valadoc_token_type_MARKDOWN_MAIL;
	_tmp53_ = valadoc_token_type_action (_tmp52_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp54_ = valadoc_token_type_MARKDOWN_LINK;
	_tmp55_ = valadoc_token_type_action (_tmp54_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp56_ = g_new0 (GObject*, 2 + 1);
	_tmp56_[0] = (GObject*) _tmp53_;
	_tmp56_[1] = (GObject*) _tmp55_;
	_tmp57_ = _tmp56_;
	_tmp57__length1 = 2;
	_tmp58_ = valadoc_rule_one_of (_tmp57_, (gint) 2);
	_tmp59_ = valadoc_token_type_MARKDOWN_GREATER_THAN;
	_tmp60_ = _g_object_ref0 ((GObject*) _tmp59_);
	_tmp61_ = g_new0 (GObject*, 1 + 1);
	_tmp61_[0] = _tmp60_;
	_tmp62_ = _tmp61_;
	_tmp62__length1 = 1;
	_tmp63_ = valadoc_rule_option (_tmp62_, (gint) 1);
	_tmp64_ = _tmp63_;
	_tmp65_ = valadoc_rule_set_reduce (_tmp64_, ___lambda17__valadoc_rule_action, self);
	_tmp66_ = _tmp65_;
	_tmp67_ = valadoc_rule_set_skip (_tmp66_, ___lambda18__valadoc_rule_action, self);
	_tmp68_ = g_new0 (GObject*, 2 + 1);
	_tmp68_[0] = (GObject*) _tmp58_;
	_tmp68_[1] = (GObject*) _tmp67_;
	_tmp69_ = _tmp68_;
	_tmp69__length1 = 2;
	_tmp70_ = valadoc_rule_option (_tmp69_, (gint) 2);
	_tmp71_ = _tmp70_;
	_tmp72_ = valadoc_rule_set_skip (_tmp71_, ___lambda19__valadoc_rule_action, self);
	_tmp73_ = g_new0 (GObject*, 2 + 1);
	_tmp73_[0] = _tmp51_;
	_tmp73_[1] = (GObject*) _tmp72_;
	_tmp74_ = _tmp73_;
	_tmp74__length1 = 2;
	_tmp75_ = valadoc_rule_seq (_tmp74_, (gint) 2);
	_tmp76_ = _tmp75_;
	_tmp77_ = valadoc_rule_set_name (_tmp76_, "Link");
	_tmp78_ = _tmp77_;
	_g_object_unref0 (_tmp76_);
	_tmp74_ = (_vala_array_free (_tmp74_, _tmp74__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp71_);
	_tmp69_ = (_vala_array_free (_tmp69_, _tmp69__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp66_);
	_g_object_unref0 (_tmp64_);
	_tmp62_ = (_vala_array_free (_tmp62_, _tmp62__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp57_ = (_vala_array_free (_tmp57_, _tmp57__length1, (GDestroyNotify) g_object_unref), NULL);
	link_short = _tmp78_;
	_tmp79_ = valadoc_token_type_MARKDOWN_OPEN_BRACKET;
	_tmp80_ = _g_object_ref0 ((GObject*) _tmp79_);
	_tmp81_ = _g_object_ref0 ((GObject*) run);
	_tmp82_ = g_new0 (GObject*, 1 + 1);
	_tmp82_[0] = _tmp81_;
	_tmp83_ = _tmp82_;
	_tmp83__length1 = 1;
	_tmp84_ = valadoc_rule_option (_tmp83_, (gint) 1);
	_tmp85_ = valadoc_token_type_MARKDOWN_CLOSE_BRACKET;
	_tmp86_ = _g_object_ref0 ((GObject*) _tmp85_);
	_tmp87_ = valadoc_token_type_MARKDOWN_OPEN_PARENS;
	_tmp88_ = _g_object_ref0 ((GObject*) _tmp87_);
	_tmp89_ = valadoc_token_type_MARKDOWN_LINK;
	_tmp90_ = valadoc_token_type_action (_tmp89_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp91_ = valadoc_token_type_MARKDOWN_MAIL;
	_tmp92_ = valadoc_token_type_action (_tmp91_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp93_ = g_new0 (GObject*, 2 + 1);
	_tmp93_[0] = (GObject*) _tmp90_;
	_tmp93_[1] = (GObject*) _tmp92_;
	_tmp94_ = _tmp93_;
	_tmp94__length1 = 2;
	_tmp95_ = valadoc_rule_one_of (_tmp94_, (gint) 2);
	_tmp96_ = valadoc_token_type_MARKDOWN_CLOSE_PARENS;
	_tmp97_ = _g_object_ref0 ((GObject*) _tmp96_);
	_tmp98_ = g_new0 (GObject*, 1 + 1);
	_tmp98_[0] = _tmp97_;
	_tmp99_ = _tmp98_;
	_tmp99__length1 = 1;
	_tmp100_ = valadoc_rule_option (_tmp99_, (gint) 1);
	_tmp101_ = _tmp100_;
	_tmp102_ = valadoc_rule_set_reduce (_tmp101_, ___lambda20__valadoc_rule_action, self);
	_tmp103_ = _tmp102_;
	_tmp104_ = valadoc_rule_set_skip (_tmp103_, ___lambda21__valadoc_rule_action, self);
	_tmp105_ = g_new0 (GObject*, 2 + 1);
	_tmp105_[0] = (GObject*) _tmp95_;
	_tmp105_[1] = (GObject*) _tmp104_;
	_tmp106_ = _tmp105_;
	_tmp106__length1 = 2;
	_tmp107_ = valadoc_rule_option (_tmp106_, (gint) 2);
	_tmp108_ = _tmp107_;
	_tmp109_ = valadoc_rule_set_skip (_tmp108_, ___lambda22__valadoc_rule_action, self);
	_tmp110_ = g_new0 (GObject*, 2 + 1);
	_tmp110_[0] = _tmp88_;
	_tmp110_[1] = (GObject*) _tmp109_;
	_tmp111_ = _tmp110_;
	_tmp111__length1 = 2;
	_tmp112_ = valadoc_rule_seq (_tmp111_, (gint) 2);
	_tmp113_ = valadoc_token_type_MARKDOWN_OPEN_BRACKET;
	_tmp114_ = _g_object_ref0 ((GObject*) _tmp113_);
	_tmp115_ = valadoc_token_type_any_word ();
	_tmp116_ = _tmp115_;
	_tmp117_ = valadoc_token_type_action (_tmp116_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp118_ = valadoc_token_type_MARKDOWN_CLOSE_BRACKET;
	_tmp119_ = _g_object_ref0 ((GObject*) _tmp118_);
	_tmp120_ = g_new0 (GObject*, 1 + 1);
	_tmp120_[0] = _tmp119_;
	_tmp121_ = _tmp120_;
	_tmp121__length1 = 1;
	_tmp122_ = valadoc_rule_option (_tmp121_, (gint) 1);
	_tmp123_ = _tmp122_;
	_tmp124_ = valadoc_rule_set_reduce (_tmp123_, ___lambda23__valadoc_rule_action, self);
	_tmp125_ = _tmp124_;
	_tmp126_ = valadoc_rule_set_skip (_tmp125_, ___lambda24__valadoc_rule_action, self);
	_tmp127_ = g_new0 (GObject*, 2 + 1);
	_tmp127_[0] = (GObject*) _tmp117_;
	_tmp127_[1] = (GObject*) _tmp126_;
	_tmp128_ = _tmp127_;
	_tmp128__length1 = 2;
	_tmp129_ = valadoc_rule_option (_tmp128_, (gint) 2);
	_tmp130_ = _tmp129_;
	_tmp131_ = valadoc_rule_set_skip (_tmp130_, ___lambda25__valadoc_rule_action, self);
	_tmp132_ = g_new0 (GObject*, 2 + 1);
	_tmp132_[0] = _tmp114_;
	_tmp132_[1] = (GObject*) _tmp131_;
	_tmp133_ = _tmp132_;
	_tmp133__length1 = 2;
	_tmp134_ = valadoc_rule_seq (_tmp133_, (gint) 2);
	_tmp135_ = g_new0 (GObject*, 2 + 1);
	_tmp135_[0] = (GObject*) _tmp112_;
	_tmp135_[1] = (GObject*) _tmp134_;
	_tmp136_ = _tmp135_;
	_tmp136__length1 = 2;
	_tmp137_ = valadoc_rule_one_of (_tmp136_, (gint) 2);
	_tmp138_ = g_new0 (GObject*, 1 + 1);
	_tmp138_[0] = (GObject*) _tmp137_;
	_tmp139_ = _tmp138_;
	_tmp139__length1 = 1;
	_tmp140_ = valadoc_rule_option (_tmp139_, (gint) 1);
	_tmp141_ = _tmp140_;
	_tmp142_ = valadoc_rule_set_skip (_tmp141_, ___lambda26__valadoc_rule_action, self);
	_tmp143_ = g_new0 (GObject*, 3 + 1);
	_tmp143_[0] = (GObject*) _tmp84_;
	_tmp143_[1] = _tmp86_;
	_tmp143_[2] = (GObject*) _tmp142_;
	_tmp144_ = _tmp143_;
	_tmp144__length1 = 3;
	_tmp145_ = valadoc_rule_option (_tmp144_, (gint) 3);
	_tmp146_ = _tmp145_;
	_tmp147_ = valadoc_rule_set_skip (_tmp146_, ___lambda27__valadoc_rule_action, self);
	_tmp148_ = g_new0 (GObject*, 2 + 1);
	_tmp148_[0] = _tmp80_;
	_tmp148_[1] = (GObject*) _tmp147_;
	_tmp149_ = _tmp148_;
	_tmp149__length1 = 2;
	_tmp150_ = valadoc_rule_seq (_tmp149_, (gint) 2);
	_tmp151_ = _tmp150_;
	_tmp152_ = valadoc_rule_set_start (_tmp151_, ___lambda28__valadoc_rule_action, self);
	_tmp153_ = _tmp152_;
	_tmp154_ = valadoc_rule_set_name (_tmp153_, "Link");
	_tmp155_ = _tmp154_;
	_g_object_unref0 (_tmp153_);
	_g_object_unref0 (_tmp151_);
	_tmp149_ = (_vala_array_free (_tmp149_, _tmp149__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp146_);
	_tmp144_ = (_vala_array_free (_tmp144_, _tmp144__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp141_);
	_tmp139_ = (_vala_array_free (_tmp139_, _tmp139__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp136_ = (_vala_array_free (_tmp136_, _tmp136__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp133_ = (_vala_array_free (_tmp133_, _tmp133__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp130_);
	_tmp128_ = (_vala_array_free (_tmp128_, _tmp128__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp125_);
	_g_object_unref0 (_tmp123_);
	_tmp121_ = (_vala_array_free (_tmp121_, _tmp121__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp116_);
	_tmp111_ = (_vala_array_free (_tmp111_, _tmp111__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp108_);
	_tmp106_ = (_vala_array_free (_tmp106_, _tmp106__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp103_);
	_g_object_unref0 (_tmp101_);
	_tmp99_ = (_vala_array_free (_tmp99_, _tmp99__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp94_ = (_vala_array_free (_tmp94_, _tmp94__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp83_ = (_vala_array_free (_tmp83_, _tmp83__length1, (GDestroyNotify) g_object_unref), NULL);
	link = _tmp155_;
	_tmp156_ = valadoc_token_type_MARKDOWN_EXCLAMATION_MARK;
	_tmp157_ = _g_object_ref0 ((GObject*) _tmp156_);
	_tmp158_ = valadoc_token_type_MARKDOWN_OPEN_BRACKET;
	_tmp159_ = _g_object_ref0 ((GObject*) _tmp158_);
	_tmp160_ = _g_object_ref0 ((GObject*) run);
	_tmp161_ = g_new0 (GObject*, 1 + 1);
	_tmp161_[0] = _tmp160_;
	_tmp162_ = _tmp161_;
	_tmp162__length1 = 1;
	_tmp163_ = valadoc_rule_option (_tmp162_, (gint) 1);
	_tmp164_ = valadoc_token_type_MARKDOWN_CLOSE_BRACKET;
	_tmp165_ = _g_object_ref0 ((GObject*) _tmp164_);
	_tmp166_ = valadoc_token_type_MARKDOWN_OPEN_BRACKET;
	_tmp167_ = _g_object_ref0 ((GObject*) _tmp166_);
	_tmp168_ = valadoc_token_type_any_word ();
	_tmp169_ = _tmp168_;
	_tmp170_ = valadoc_token_type_action (_tmp169_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp171_ = valadoc_token_type_MARKDOWN_LINK;
	_tmp172_ = valadoc_token_type_action (_tmp171_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp173_ = valadoc_token_type_MARKDOWN_MAIL;
	_tmp174_ = valadoc_token_type_action (_tmp173_, _valadoc_gtkdoc_markdown_parser_preserve_token_valadoc_token_type_action, self);
	_tmp175_ = g_new0 (GObject*, 3 + 1);
	_tmp175_[0] = (GObject*) _tmp170_;
	_tmp175_[1] = (GObject*) _tmp172_;
	_tmp175_[2] = (GObject*) _tmp174_;
	_tmp176_ = _tmp175_;
	_tmp176__length1 = 3;
	_tmp177_ = valadoc_rule_one_of (_tmp176_, (gint) 3);
	_tmp178_ = valadoc_token_type_MARKDOWN_CLOSE_BRACKET;
	_tmp179_ = _g_object_ref0 ((GObject*) _tmp178_);
	_tmp180_ = g_new0 (GObject*, 1 + 1);
	_tmp180_[0] = _tmp179_;
	_tmp181_ = _tmp180_;
	_tmp181__length1 = 1;
	_tmp182_ = valadoc_rule_option (_tmp181_, (gint) 1);
	_tmp183_ = _tmp182_;
	_tmp184_ = valadoc_rule_set_reduce (_tmp183_, ___lambda29__valadoc_rule_action, self);
	_tmp185_ = _tmp184_;
	_tmp186_ = valadoc_rule_set_skip (_tmp185_, ___lambda30__valadoc_rule_action, self);
	_tmp187_ = g_new0 (GObject*, 2 + 1);
	_tmp187_[0] = (GObject*) _tmp177_;
	_tmp187_[1] = (GObject*) _tmp186_;
	_tmp188_ = _tmp187_;
	_tmp188__length1 = 2;
	_tmp189_ = valadoc_rule_option (_tmp188_, (gint) 2);
	_tmp190_ = _tmp189_;
	_tmp191_ = valadoc_rule_set_skip (_tmp190_, ___lambda31__valadoc_rule_action, self);
	_tmp192_ = g_new0 (GObject*, 2 + 1);
	_tmp192_[0] = _tmp167_;
	_tmp192_[1] = (GObject*) _tmp191_;
	_tmp193_ = _tmp192_;
	_tmp193__length1 = 2;
	_tmp194_ = valadoc_rule_option (_tmp193_, (gint) 2);
	_tmp195_ = _tmp194_;
	_tmp196_ = valadoc_rule_set_skip (_tmp195_, ___lambda32__valadoc_rule_action, self);
	_tmp197_ = g_new0 (GObject*, 4 + 1);
	_tmp197_[0] = _tmp159_;
	_tmp197_[1] = (GObject*) _tmp163_;
	_tmp197_[2] = _tmp165_;
	_tmp197_[3] = (GObject*) _tmp196_;
	_tmp198_ = _tmp197_;
	_tmp198__length1 = 4;
	_tmp199_ = valadoc_rule_option (_tmp198_, (gint) 4);
	_tmp200_ = _tmp199_;
	_tmp201_ = valadoc_rule_set_skip (_tmp200_, ___lambda33__valadoc_rule_action, self);
	_tmp202_ = g_new0 (GObject*, 2 + 1);
	_tmp202_[0] = _tmp157_;
	_tmp202_[1] = (GObject*) _tmp201_;
	_tmp203_ = _tmp202_;
	_tmp203__length1 = 2;
	_tmp204_ = valadoc_rule_seq (_tmp203_, (gint) 2);
	_tmp205_ = _tmp204_;
	_tmp206_ = valadoc_rule_set_start (_tmp205_, ___lambda34__valadoc_rule_action, self);
	_tmp207_ = _tmp206_;
	_tmp208_ = valadoc_rule_set_name (_tmp207_, "Image");
	_tmp209_ = _tmp208_;
	_g_object_unref0 (_tmp207_);
	_g_object_unref0 (_tmp205_);
	_tmp203_ = (_vala_array_free (_tmp203_, _tmp203__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp200_);
	_tmp198_ = (_vala_array_free (_tmp198_, _tmp198__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp195_);
	_tmp193_ = (_vala_array_free (_tmp193_, _tmp193__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp190_);
	_tmp188_ = (_vala_array_free (_tmp188_, _tmp188__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp185_);
	_g_object_unref0 (_tmp183_);
	_tmp181_ = (_vala_array_free (_tmp181_, _tmp181__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp176_ = (_vala_array_free (_tmp176_, _tmp176__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp169_);
	_tmp162_ = (_vala_array_free (_tmp162_, _tmp162__length1, (GDestroyNotify) g_object_unref), NULL);
	image = _tmp209_;
	_tmp210_ = valadoc_token_type_MARKDOWN_SOURCE;
	_tmp211_ = valadoc_token_type_action (_tmp210_, ___lambda35__valadoc_token_type_action, self);
	_tmp212_ = g_new0 (GObject*, 1 + 1);
	_tmp212_[0] = (GObject*) _tmp211_;
	_tmp213_ = _tmp212_;
	_tmp213__length1 = 1;
	_tmp214_ = valadoc_rule_seq (_tmp213_, (gint) 1);
	_tmp215_ = _tmp214_;
	_tmp216_ = valadoc_rule_set_name (_tmp215_, "Source");
	_tmp217_ = _tmp216_;
	_g_object_unref0 (_tmp215_);
	_tmp213_ = (_vala_array_free (_tmp213_, _tmp213__length1, (GDestroyNotify) g_object_unref), NULL);
	source = _tmp217_;
	_tmp218_ = _g_object_ref0 ((GObject*) word);
	_tmp219_ = valadoc_token_type_MARKDOWN_SPACE;
	_tmp220_ = valadoc_token_type_action (_tmp219_, _valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action, self);
	_tmp221_ = valadoc_token_type_MARKDOWN_MAIL;
	_tmp222_ = valadoc_token_type_action (_tmp221_, _valadoc_gtkdoc_markdown_parser_add_value_valadoc_token_type_action, self);
	_tmp223_ = valadoc_token_type_MARKDOWN_LINK;
	_tmp224_ = valadoc_token_type_action (_tmp223_, _valadoc_gtkdoc_markdown_parser_add_value_valadoc_token_type_action, self);
	_tmp225_ = valadoc_token_type_MARKDOWN_OPEN_PARENS;
	_tmp226_ = valadoc_token_type_action (_tmp225_, _valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action, self);
	_tmp227_ = valadoc_token_type_MARKDOWN_CLOSE_PARENS;
	_tmp228_ = valadoc_token_type_action (_tmp227_, _valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action, self);
	_tmp229_ = valadoc_token_type_MARKDOWN_CLOSE_BRACKET;
	_tmp230_ = valadoc_token_type_action (_tmp229_, _valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action, self);
	_tmp231_ = valadoc_token_type_MARKDOWN_GREATER_THAN;
	_tmp232_ = valadoc_token_type_action (_tmp231_, _valadoc_gtkdoc_markdown_parser_add_text_valadoc_token_type_action, self);
	_tmp233_ = g_new0 (GObject*, 8 + 1);
	_tmp233_[0] = _tmp218_;
	_tmp233_[1] = (GObject*) _tmp220_;
	_tmp233_[2] = (GObject*) _tmp222_;
	_tmp233_[3] = (GObject*) _tmp224_;
	_tmp233_[4] = (GObject*) _tmp226_;
	_tmp233_[5] = (GObject*) _tmp228_;
	_tmp233_[6] = (GObject*) _tmp230_;
	_tmp233_[7] = (GObject*) _tmp232_;
	_tmp234_ = _tmp233_;
	_tmp234__length1 = 8;
	_tmp235_ = valadoc_rule_one_of (_tmp234_, (gint) 8);
	_tmp236_ = g_new0 (GObject*, 1 + 1);
	_tmp236_[0] = (GObject*) _tmp235_;
	_tmp237_ = _tmp236_;
	_tmp237__length1 = 1;
	_tmp238_ = valadoc_rule_many (_tmp237_, (gint) 1);
	_tmp239_ = _tmp238_;
	_tmp240_ = valadoc_rule_set_start (_tmp239_, ___lambda36__valadoc_rule_action, self);
	_tmp241_ = _tmp240_;
	_tmp242_ = valadoc_rule_set_name (_tmp241_, "Text");
	_tmp243_ = _tmp242_;
	_g_object_unref0 (_tmp241_);
	_g_object_unref0 (_tmp239_);
	_tmp237_ = (_vala_array_free (_tmp237_, _tmp237__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp234_ = (_vala_array_free (_tmp234_, _tmp234__length1, (GDestroyNotify) g_object_unref), NULL);
	text = _tmp243_;
	_tmp244_ = _g_object_ref0 ((GObject*) text);
	_tmp245_ = _g_object_ref0 ((GObject*) link);
	_tmp246_ = _g_object_ref0 ((GObject*) link_short);
	_tmp247_ = _g_object_ref0 ((GObject*) image);
	_tmp248_ = _g_object_ref0 ((GObject*) function);
	_tmp249_ = _g_object_ref0 ((GObject*) constant);
	_tmp250_ = _g_object_ref0 ((GObject*) param);
	_tmp251_ = _g_object_ref0 ((GObject*) symbol);
	_tmp252_ = _g_object_ref0 ((GObject*) gmember);
	_tmp253_ = _g_object_ref0 ((GObject*) source);
	_tmp254_ = g_new0 (GObject*, 10 + 1);
	_tmp254_[0] = _tmp244_;
	_tmp254_[1] = _tmp245_;
	_tmp254_[2] = _tmp246_;
	_tmp254_[3] = _tmp247_;
	_tmp254_[4] = _tmp248_;
	_tmp254_[5] = _tmp249_;
	_tmp254_[6] = _tmp250_;
	_tmp254_[7] = _tmp251_;
	_tmp254_[8] = _tmp252_;
	_tmp254_[9] = _tmp253_;
	_tmp255_ = _tmp254_;
	_tmp255__length1 = 10;
	_tmp256_ = valadoc_rule_one_of (_tmp255_, (gint) 10);
	_tmp257_ = _tmp256_;
	_tmp258_ = valadoc_rule_set_reduce (_tmp257_, ___lambda37__valadoc_rule_action, self);
	_tmp259_ = g_new0 (GObject*, 1 + 1);
	_tmp259_[0] = (GObject*) _tmp258_;
	_tmp260_ = _tmp259_;
	_tmp260__length1 = 1;
	_tmp261_ = valadoc_rule_many (_tmp260_, (gint) 1);
	_tmp262_ = _tmp261_;
	_tmp263_ = valadoc_stub_rule_set_rule (run, _tmp262_);
	_tmp264_ = _tmp263_;
	_g_object_unref0 (_tmp264_);
	_g_object_unref0 (_tmp262_);
	_tmp260_ = (_vala_array_free (_tmp260_, _tmp260__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp257_);
	_tmp255_ = (_vala_array_free (_tmp255_, _tmp255__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp265_ = valadoc_token_type_MARKDOWN_UNORDERED_LIST_ITEM_START;
	_tmp266_ = _g_object_ref0 ((GObject*) _tmp265_);
	_tmp267_ = _g_object_ref0 ((GObject*) content);
	_tmp268_ = valadoc_token_type_MARKDOWN_UNORDERED_LIST_ITEM_END;
	_tmp269_ = _g_object_ref0 ((GObject*) _tmp268_);
	_tmp270_ = g_new0 (GObject*, 3 + 1);
	_tmp270_[0] = _tmp266_;
	_tmp270_[1] = _tmp267_;
	_tmp270_[2] = _tmp269_;
	_tmp271_ = _tmp270_;
	_tmp271__length1 = 3;
	_tmp272_ = valadoc_rule_seq (_tmp271_, (gint) 3);
	_tmp273_ = _tmp272_;
	_tmp274_ = valadoc_rule_set_start (_tmp273_, ___lambda38__valadoc_rule_action, self);
	_tmp275_ = _tmp274_;
	_tmp276_ = valadoc_rule_set_reduce (_tmp275_, ___lambda39__valadoc_rule_action, self);
	_tmp277_ = g_new0 (GObject*, 1 + 1);
	_tmp277_[0] = (GObject*) _tmp276_;
	_tmp278_ = _tmp277_;
	_tmp278__length1 = 1;
	_tmp279_ = valadoc_rule_seq (_tmp278_, (gint) 1);
	_tmp280_ = _tmp279_;
	_tmp281_ = valadoc_rule_set_start (_tmp280_, ___lambda40__valadoc_rule_action, self);
	_tmp282_ = _tmp281_;
	_tmp283_ = valadoc_rule_set_reduce (_tmp282_, ___lambda41__valadoc_rule_action, self);
	_tmp284_ = _tmp283_;
	_tmp285_ = valadoc_rule_set_name (_tmp284_, "UnorderedList");
	_tmp286_ = _tmp285_;
	_g_object_unref0 (_tmp284_);
	_g_object_unref0 (_tmp282_);
	_g_object_unref0 (_tmp280_);
	_tmp278_ = (_vala_array_free (_tmp278_, _tmp278__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp275_);
	_g_object_unref0 (_tmp273_);
	_tmp271_ = (_vala_array_free (_tmp271_, _tmp271__length1, (GDestroyNotify) g_object_unref), NULL);
	unordered_list = _tmp286_;
	_tmp287_ = valadoc_token_type_MARKDOWN_ORDERED_LIST_ITEM_START;
	_tmp288_ = _g_object_ref0 ((GObject*) _tmp287_);
	_tmp289_ = _g_object_ref0 ((GObject*) content);
	_tmp290_ = valadoc_token_type_MARKDOWN_ORDERED_LIST_ITEM_END;
	_tmp291_ = _g_object_ref0 ((GObject*) _tmp290_);
	_tmp292_ = g_new0 (GObject*, 3 + 1);
	_tmp292_[0] = _tmp288_;
	_tmp292_[1] = _tmp289_;
	_tmp292_[2] = _tmp291_;
	_tmp293_ = _tmp292_;
	_tmp293__length1 = 3;
	_tmp294_ = valadoc_rule_seq (_tmp293_, (gint) 3);
	_tmp295_ = _tmp294_;
	_tmp296_ = valadoc_rule_set_start (_tmp295_, ___lambda42__valadoc_rule_action, self);
	_tmp297_ = _tmp296_;
	_tmp298_ = valadoc_rule_set_reduce (_tmp297_, ___lambda43__valadoc_rule_action, self);
	_tmp299_ = g_new0 (GObject*, 1 + 1);
	_tmp299_[0] = (GObject*) _tmp298_;
	_tmp300_ = _tmp299_;
	_tmp300__length1 = 1;
	_tmp301_ = valadoc_rule_seq (_tmp300_, (gint) 1);
	_tmp302_ = _tmp301_;
	_tmp303_ = valadoc_rule_set_start (_tmp302_, ___lambda44__valadoc_rule_action, self);
	_tmp304_ = _tmp303_;
	_tmp305_ = valadoc_rule_set_reduce (_tmp304_, ___lambda45__valadoc_rule_action, self);
	_tmp306_ = _tmp305_;
	_tmp307_ = valadoc_rule_set_name (_tmp306_, "OrderedList");
	_tmp308_ = _tmp307_;
	_g_object_unref0 (_tmp306_);
	_g_object_unref0 (_tmp304_);
	_g_object_unref0 (_tmp302_);
	_tmp300_ = (_vala_array_free (_tmp300_, _tmp300__length1, (GDestroyNotify) g_object_unref), NULL);
	_g_object_unref0 (_tmp297_);
	_g_object_unref0 (_tmp295_);
	_tmp293_ = (_vala_array_free (_tmp293_, _tmp293__length1, (GDestroyNotify) g_object_unref), NULL);
	ordered_list = _tmp308_;
	_tmp309_ = valadoc_token_type_MARKDOWN_PARAGRAPH;
	_tmp310_ = _g_object_ref0 ((GObject*) _tmp309_);
	_tmp311_ = valadoc_token_type_MARKDOWN_SPACE;
	_tmp312_ = _g_object_ref0 ((GObject*) _tmp311_);
	_tmp313_ = g_new0 (GObject*, 1 + 1);
	_tmp313_[0] = _tmp312_;
	_tmp314_ = _tmp313_;
	_tmp314__length1 = 1;
	_tmp315_ = valadoc_rule_option (_tmp314_, (gint) 1);
	_tmp316_ = _g_object_ref0 ((GObject*) run);
	_tmp317_ = g_new0 (GObject*, 1 + 1);
	_tmp317_[0] = _tmp316_;
	_tmp318_ = _tmp317_;
	_tmp318__length1 = 1;
	_tmp319_ = valadoc_rule_option (_tmp318_, (gint) 1);
	_tmp320_ = g_new0 (GObject*, 3 + 1);
	_tmp320_[0] = _tmp310_;
	_tmp320_[1] = (GObject*) _tmp315_;
	_tmp320_[2] = (GObject*) _tmp319_;
	_tmp321_ = _tmp320_;
	_tmp321__length1 = 3;
	_tmp322_ = valadoc_rule_seq (_tmp321_, (gint) 3);
	_tmp323_ = _tmp322_;
	_tmp324_ = valadoc_rule_set_start (_tmp323_, ___lambda46__valadoc_rule_action, self);
	_tmp325_ = _tmp324_;
	_tmp326_ = valadoc_rule_set_reduce (_tmp325_, ___lambda47__valadoc_rule_action, self);
	_tmp327_ = _tmp326_;
	_tmp328_ = valadoc_rule_set_name (_tmp327_, "Paragraph");
	_tmp329_ = _tmp328_;
	_g_object_unref0 (_tmp327_);
	_g_object_unref0 (_tmp325_);
	_g_object_unref0 (_tmp323_);
	_tmp321_ = (_vala_array_free (_tmp321_, _tmp321__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp318_ = (_vala_array_free (_tmp318_, _tmp318__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp314_ = (_vala_array_free (_tmp314_, _tmp314__length1, (GDestroyNotify) g_object_unref), NULL);
	paragraph = _tmp329_;
	_tmp330_ = valadoc_token_type_MARKDOWN_BLOCK_START;
	_tmp331_ = _g_object_ref0 ((GObject*) _tmp330_);
	_tmp332_ = _g_object_ref0 ((GObject*) content);
	_tmp333_ = valadoc_token_type_MARKDOWN_BLOCK_END;
	_tmp334_ = _g_object_ref0 ((GObject*) _tmp333_);
	_tmp335_ = g_new0 (GObject*, 3 + 1);
	_tmp335_[0] = _tmp331_;
	_tmp335_[1] = _tmp332_;
	_tmp335_[2] = _tmp334_;
	_tmp336_ = _tmp335_;
	_tmp336__length1 = 3;
	_tmp337_ = valadoc_rule_seq (_tmp336_, (gint) 3);
	_tmp338_ = _tmp337_;
	_tmp339_ = valadoc_rule_set_start (_tmp338_, ___lambda48__valadoc_rule_action, self);
	_tmp340_ = _tmp339_;
	_tmp341_ = valadoc_rule_set_reduce (_tmp340_, ___lambda49__valadoc_rule_action, self);
	_tmp342_ = _tmp341_;
	_tmp343_ = valadoc_rule_set_name (_tmp342_, "Block");
	_tmp344_ = _tmp343_;
	_g_object_unref0 (_tmp342_);
	_g_object_unref0 (_tmp340_);
	_g_object_unref0 (_tmp338_);
	_tmp336_ = (_vala_array_free (_tmp336_, _tmp336__length1, (GDestroyNotify) g_object_unref), NULL);
	block = _tmp344_;
	_tmp345_ = valadoc_token_type_MARKDOWN_HEADLINE_1;
	_tmp346_ = valadoc_token_type_action (_tmp345_, ___lambda50__valadoc_token_type_action, self);
	_tmp347_ = valadoc_token_type_MARKDOWN_HEADLINE_2;
	_tmp348_ = valadoc_token_type_action (_tmp347_, ___lambda51__valadoc_token_type_action, self);
	_tmp349_ = g_new0 (GObject*, 2 + 1);
	_tmp349_[0] = (GObject*) _tmp346_;
	_tmp349_[1] = (GObject*) _tmp348_;
	_tmp350_ = _tmp349_;
	_tmp350__length1 = 2;
	_tmp351_ = valadoc_rule_one_of (_tmp350_, (gint) 2);
	_tmp352_ = _g_object_ref0 ((GObject*) run);
	_tmp353_ = valadoc_token_type_MARKDOWN_HEADLINE_HASH;
	_tmp354_ = valadoc_token_type_action (_tmp353_, ___lambda52__valadoc_token_type_action, self);
	_tmp355_ = g_new0 (GObject*, 1 + 1);
	_tmp355_[0] = (GObject*) _tmp354_;
	_tmp356_ = _tmp355_;
	_tmp356__length1 = 1;
	_tmp357_ = valadoc_rule_option (_tmp356_, (gint) 1);
	_tmp358_ = valadoc_token_type_MARKDOWN_HEADLINE_END;
	_tmp359_ = _g_object_ref0 ((GObject*) _tmp358_);
	_tmp360_ = g_new0 (GObject*, 4 + 1);
	_tmp360_[0] = (GObject*) _tmp351_;
	_tmp360_[1] = _tmp352_;
	_tmp360_[2] = (GObject*) _tmp357_;
	_tmp360_[3] = _tmp359_;
	_tmp361_ = _tmp360_;
	_tmp361__length1 = 4;
	_tmp362_ = valadoc_rule_seq (_tmp361_, (gint) 4);
	_tmp363_ = _tmp362_;
	_tmp364_ = valadoc_rule_set_start (_tmp363_, ___lambda53__valadoc_rule_action, self);
	_tmp365_ = _tmp364_;
	_tmp366_ = valadoc_rule_set_reduce (_tmp365_, ___lambda54__valadoc_rule_action, self);
	_tmp367_ = _tmp366_;
	_tmp368_ = valadoc_rule_set_name (_tmp367_, "Headline");
	_tmp369_ = _tmp368_;
	_g_object_unref0 (_tmp367_);
	_g_object_unref0 (_tmp365_);
	_g_object_unref0 (_tmp363_);
	_tmp361_ = (_vala_array_free (_tmp361_, _tmp361__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp356_ = (_vala_array_free (_tmp356_, _tmp356__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp350_ = (_vala_array_free (_tmp350_, _tmp350__length1, (GDestroyNotify) g_object_unref), NULL);
	headline = _tmp369_;
	_tmp370_ = _g_object_ref0 ((GObject*) paragraph);
	_tmp371_ = _g_object_ref0 ((GObject*) unordered_list);
	_tmp372_ = _g_object_ref0 ((GObject*) ordered_list);
	_tmp373_ = _g_object_ref0 ((GObject*) headline);
	_tmp374_ = _g_object_ref0 ((GObject*) block);
	_tmp375_ = g_new0 (GObject*, 5 + 1);
	_tmp375_[0] = _tmp370_;
	_tmp375_[1] = _tmp371_;
	_tmp375_[2] = _tmp372_;
	_tmp375_[3] = _tmp373_;
	_tmp375_[4] = _tmp374_;
	_tmp376_ = _tmp375_;
	_tmp376__length1 = 5;
	_tmp377_ = valadoc_rule_one_of (_tmp376_, (gint) 5);
	_tmp378_ = g_new0 (GObject*, 1 + 1);
	_tmp378_[0] = (GObject*) _tmp377_;
	_tmp379_ = _tmp378_;
	_tmp379__length1 = 1;
	_tmp380_ = valadoc_rule_many (_tmp379_, (gint) 1);
	_tmp381_ = _tmp380_;
	_tmp382_ = valadoc_stub_rule_set_rule (content, _tmp381_);
	_tmp383_ = _tmp382_;
	_g_object_unref0 (_tmp383_);
	_g_object_unref0 (_tmp381_);
	_tmp379_ = (_vala_array_free (_tmp379_, _tmp379__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp376_ = (_vala_array_free (_tmp376_, _tmp376__length1, (GDestroyNotify) g_object_unref), NULL);
	_tmp384_ = _g_object_ref0 ((GObject*) content);
	_tmp385_ = valadoc_token_type_MARKDOWN_EOC;
	_tmp386_ = _g_object_ref0 ((GObject*) _tmp385_);
	_tmp387_ = g_new0 (GObject*, 2 + 1);
	_tmp387_[0] = _tmp384_;
	_tmp387_[1] = _tmp386_;
	_tmp388_ = _tmp387_;
	_tmp388__length1 = 2;
	_tmp389_ = valadoc_rule_seq (_tmp388_, (gint) 2);
	_tmp390_ = _tmp389_;
	_tmp391_ = valadoc_rule_set_start (_tmp390_, ___lambda55__valadoc_rule_action, self);
	_tmp392_ = _tmp391_;
	_tmp393_ = valadoc_rule_set_name (_tmp392_, "Comment");
	_tmp394_ = _tmp393_;
	_g_object_unref0 (_tmp392_);
	_g_object_unref0 (_tmp390_);
	_tmp388_ = (_vala_array_free (_tmp388_, _tmp388__length1, (GDestroyNotify) g_object_unref), NULL);
	comment = _tmp394_;
	_tmp395_ = self->priv->parser;
	valadoc_parser_set_root_rule (_tmp395_, comment);
	_g_object_unref0 (comment);
	_g_object_unref0 (headline);
	_g_object_unref0 (block);
	_g_object_unref0 (paragraph);
	_g_object_unref0 (ordered_list);
	_g_object_unref0 (unordered_list);
	_g_object_unref0 (text);
	_g_object_unref0 (source);
	_g_object_unref0 (image);
	_g_object_unref0 (link);
	_g_object_unref0 (link_short);
	_g_object_unref0 (function);
	_g_object_unref0 (symbol);
	_g_object_unref0 (gmember);
	_g_object_unref0 (constant);
	_g_object_unref0 (param);
	_g_object_unref0 (run);
	_g_object_unref0 (content);
	_g_object_unref0 (word);
}

static ValadocContentComment*
_valadoc_gtkdoc_markdown_parser_parse (ValadocGtkdocMarkdownParser* self,
                                       ValadocApiSourceComment* comment)
{
	GError* _inner_error0_ = NULL;
	ValadocContentComment* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (comment != NULL, NULL);
	{
		ValaArrayList* _tmp0_;
		ValadocParser* _tmp1_;
		const gchar* _tmp2_;
		const gchar* _tmp3_;
		ValadocApiSourceFile* _tmp4_;
		ValadocApiSourceFile* _tmp5_;
		gchar* _tmp6_;
		gchar* _tmp7_;
		gint _tmp8_;
		gint _tmp9_;
		gint _tmp10_;
		gint _tmp11_;
		GObject* _tmp12_;
		_tmp0_ = self->priv->_stack;
		vala_collection_clear ((ValaCollection*) _tmp0_);
		_tmp1_ = self->priv->parser;
		_tmp2_ = valadoc_api_source_comment_get_content (comment);
		_tmp3_ = _tmp2_;
		_tmp4_ = valadoc_api_source_comment_get_file (comment);
		_tmp5_ = _tmp4_;
		_tmp6_ = valadoc_api_source_file_get_name (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = valadoc_api_source_comment_get_first_line (comment);
		_tmp9_ = _tmp8_;
		_tmp10_ = valadoc_api_source_comment_get_first_column (comment);
		_tmp11_ = _tmp10_;
		valadoc_parser_parse (_tmp1_, _tmp3_, _tmp7_, _tmp9_, _tmp11_, &_inner_error0_);
		_g_free0 (_tmp7_);
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
				goto __catch0_valadoc_parser_error;
			}
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
		_tmp12_ = valadoc_gtkdoc_markdown_parser_pop (self);
		result = G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALADOC_CONTENT_TYPE_COMMENT, ValadocContentComment);
		return result;
	}
	goto __finally0;
	__catch0_valadoc_parser_error:
	{
		g_clear_error (&_inner_error0_);
		result = NULL;
		return result;
	}
	__finally0:
	g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
	g_clear_error (&_inner_error0_);
	return NULL;
}

static ValadocContentTaglet*
_valadoc_gtkdoc_markdown_parser_parse_block_taglet (ValadocGtkdocMarkdownParser* self,
                                                    ValadocApiSourceComment* comment,
                                                    const gchar* taglet_name)
{
	ValadocContentComment* cmnt = NULL;
	ValadocContentComment* _tmp0_;
	ValadocContentComment* _tmp1_;
	ValadocContentTaglet* taglet = NULL;
	ValadocContentContentFactory* _tmp2_;
	ValadocContentTaglet* _tmp3_;
	ValadocContentBlockContent* block = NULL;
	ValadocContentTaglet* _tmp4_;
	ValadocContentBlockContent* _tmp5_;
	gboolean _tmp6_ = FALSE;
	ValadocContentTaglet* _tmp7_;
	ValadocContentBlockContent* _tmp9_;
	ValaList* _tmp10_;
	ValaList* _tmp11_;
	ValadocContentComment* _tmp12_;
	ValaList* _tmp13_;
	ValaList* _tmp14_;
	ValadocContentTaglet* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (comment != NULL, NULL);
	g_return_val_if_fail (taglet_name != NULL, NULL);
	_tmp0_ = _valadoc_gtkdoc_markdown_parser_parse (self, comment);
	cmnt = _tmp0_;
	_tmp1_ = cmnt;
	if (_tmp1_ == NULL) {
		result = NULL;
		_g_object_unref0 (cmnt);
		return result;
	}
	_tmp2_ = self->priv->_factory;
	_tmp3_ = valadoc_content_content_factory_create_taglet (_tmp2_, taglet_name);
	taglet = _tmp3_;
	_tmp4_ = taglet;
	_tmp5_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALADOC_CONTENT_TYPE_BLOCK_CONTENT, ValadocContentBlockContent));
	block = _tmp5_;
	_tmp7_ = taglet;
	if (_tmp7_ != NULL) {
		ValadocContentBlockContent* _tmp8_;
		_tmp8_ = block;
		_tmp6_ = _tmp8_ != NULL;
	} else {
		_tmp6_ = FALSE;
	}
	_vala_assert (_tmp6_, "taglet != null && block != null");
	_tmp9_ = block;
	_tmp10_ = valadoc_content_block_content_get_content (_tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = cmnt;
	_tmp13_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp12_);
	_tmp14_ = _tmp13_;
	vala_collection_add_all ((ValaCollection*) _tmp11_, (ValaCollection*) _tmp14_);
	result = taglet;
	_g_object_unref0 (block);
	_g_object_unref0 (cmnt);
	return result;
}

static ValadocContentNote*
_valadoc_gtkdoc_markdown_parser_parse_note (ValadocGtkdocMarkdownParser* self,
                                            ValadocApiSourceComment* comment)
{
	ValadocContentComment* cmnt = NULL;
	ValadocContentComment* _tmp0_;
	ValadocContentComment* _tmp1_;
	ValadocContentNote* note = NULL;
	ValadocContentContentFactory* _tmp2_;
	ValadocContentNote* _tmp3_;
	ValadocContentNote* _tmp4_;
	ValaList* _tmp5_;
	ValaList* _tmp6_;
	ValadocContentComment* _tmp7_;
	ValaList* _tmp8_;
	ValaList* _tmp9_;
	ValadocContentNote* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (comment != NULL, NULL);
	_tmp0_ = _valadoc_gtkdoc_markdown_parser_parse (self, comment);
	cmnt = _tmp0_;
	_tmp1_ = cmnt;
	if (_tmp1_ == NULL) {
		result = NULL;
		_g_object_unref0 (cmnt);
		return result;
	}
	_tmp2_ = self->priv->_factory;
	_tmp3_ = valadoc_content_content_factory_create_note (_tmp2_);
	note = _tmp3_;
	_tmp4_ = note;
	_tmp5_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = cmnt;
	_tmp8_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp7_);
	_tmp9_ = _tmp8_;
	vala_collection_add_all ((ValaCollection*) _tmp6_, (ValaCollection*) _tmp9_);
	result = note;
	_g_object_unref0 (cmnt);
	return result;
}

static void
valadoc_gtkdoc_markdown_parser_add_taglet (ValadocGtkdocMarkdownParser* self,
                                           ValadocContentComment** comment,
                                           ValadocContentTaglet* taglet)
{
	ValaList* _tmp2_;
	ValaList* _tmp3_;
	g_return_if_fail (self != NULL);
	if (taglet == NULL) {
		return;
	}
	if ((*comment) == NULL) {
		ValadocContentContentFactory* _tmp0_;
		ValadocContentComment* _tmp1_;
		_tmp0_ = self->priv->_factory;
		_tmp1_ = valadoc_content_content_factory_create_comment (_tmp0_);
		_g_object_unref0 (*comment);
		*comment = _tmp1_;
	}
	_tmp2_ = valadoc_content_comment_get_taglets (*comment);
	_tmp3_ = _tmp2_;
	vala_collection_add ((ValaCollection*) _tmp3_, taglet);
}

static void
valadoc_gtkdoc_markdown_parser_add_note (ValadocGtkdocMarkdownParser* self,
                                         ValadocContentComment** comment,
                                         ValadocContentNote* note)
{
	ValaList* _tmp2_;
	ValaList* _tmp3_;
	gint _tmp4_;
	gint _tmp5_;
	ValaList* _tmp11_;
	ValaList* _tmp12_;
	g_return_if_fail (self != NULL);
	if (note == NULL) {
		return;
	}
	if ((*comment) == NULL) {
		ValadocContentContentFactory* _tmp0_;
		ValadocContentComment* _tmp1_;
		_tmp0_ = self->priv->_factory;
		_tmp1_ = valadoc_content_content_factory_create_comment (_tmp0_);
		_g_object_unref0 (*comment);
		*comment = _tmp1_;
	}
	_tmp2_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) (*comment));
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
	_tmp5_ = _tmp4_;
	if (_tmp5_ == 0) {
		ValaList* _tmp6_;
		ValaList* _tmp7_;
		ValadocContentContentFactory* _tmp8_;
		ValadocContentParagraph* _tmp9_;
		ValadocContentParagraph* _tmp10_;
		_tmp6_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) (*comment));
		_tmp7_ = _tmp6_;
		_tmp8_ = self->priv->_factory;
		_tmp9_ = valadoc_content_content_factory_create_paragraph (_tmp8_);
		_tmp10_ = _tmp9_;
		vala_collection_add ((ValaCollection*) _tmp7_, (ValadocContentBlock*) _tmp10_);
		_g_object_unref0 (_tmp10_);
	}
	_tmp11_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) (*comment));
	_tmp12_ = _tmp11_;
	vala_list_insert (_tmp12_, 1, (ValadocContentBlock*) note);
}

static gpointer
_valadoc_importer_internal_id_registrar_ref0 (gpointer self)
{
	return self ? valadoc_importer_internal_id_registrar_ref (self) : NULL;
}

static gpointer
_valadoc_api_source_comment_ref0 (gpointer self)
{
	return self ? valadoc_api_source_comment_ref (self) : NULL;
}

ValadocContentComment*
valadoc_gtkdoc_markdown_parser_parse (ValadocGtkdocMarkdownParser* self,
                                      ValadocApiNode* element,
                                      ValadocApiGirSourceComment* gir_comment,
                                      ValadocGirMetaData* metadata,
                                      ValadocImporterInternalIdRegistrar* id_registrar,
                                      const gchar* this_name)
{
	ValadocGirMetaData* _tmp0_;
	ValadocImporterInternalIdRegistrar* _tmp1_;
	ValadocApiGirSourceComment* _tmp2_;
	ValadocApiNode* _tmp3_;
	ValadocContentComment* cmnt = NULL;
	ValadocContentComment* _tmp4_;
	ValadocContentComment* _tmp5_;
	ValadocApiSourceComment* _tmp8_;
	ValadocApiSourceComment* _tmp9_;
	ValadocApiSourceComment* _tmp14_;
	ValadocApiSourceComment* _tmp15_;
	ValadocApiSourceComment* _tmp20_;
	ValadocApiSourceComment* _tmp21_;
	ValadocApiSourceComment* _tmp26_;
	ValadocApiSourceComment* _tmp27_;
	ValaMapIterator* iter = NULL;
	ValaMapIterator* _tmp32_;
	ValadocContentComment* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (element != NULL, NULL);
	g_return_val_if_fail (gir_comment != NULL, NULL);
	g_return_val_if_fail (metadata != NULL, NULL);
	g_return_val_if_fail (id_registrar != NULL, NULL);
	_tmp0_ = _g_object_ref0 (metadata);
	_g_object_unref0 (self->priv->metadata);
	self->priv->metadata = _tmp0_;
	_tmp1_ = _valadoc_importer_internal_id_registrar_ref0 (id_registrar);
	_valadoc_importer_internal_id_registrar_unref0 (self->priv->id_registrar);
	self->priv->id_registrar = _tmp1_;
	_tmp2_ = _valadoc_api_source_comment_ref0 (gir_comment);
	_valadoc_api_source_comment_unref0 (self->priv->gir_comment);
	self->priv->gir_comment = _tmp2_;
	_tmp3_ = _g_object_ref0 (element);
	_g_object_unref0 (self->priv->element);
	self->priv->element = _tmp3_;
	_tmp4_ = _valadoc_gtkdoc_markdown_parser_parse (self, (ValadocApiSourceComment*) gir_comment);
	cmnt = _tmp4_;
	_tmp5_ = cmnt;
	if (_tmp5_ != NULL) {
		ValadocContentComment* _tmp6_;
		ValadocContentContentFactory* _tmp7_;
		_tmp6_ = cmnt;
		_tmp7_ = self->priv->_factory;
		valadoc_importer_helper_extract_short_desc (_tmp6_, _tmp7_);
	}
	_tmp8_ = valadoc_api_gir_source_comment_get_deprecated_comment (gir_comment);
	_tmp9_ = _tmp8_;
	if (_tmp9_ != NULL) {
		ValadocContentNote* note = NULL;
		ValadocApiSourceComment* _tmp10_;
		ValadocApiSourceComment* _tmp11_;
		ValadocContentNote* _tmp12_;
		ValadocContentNote* _tmp13_;
		_tmp10_ = valadoc_api_gir_source_comment_get_deprecated_comment (gir_comment);
		_tmp11_ = _tmp10_;
		_tmp12_ = _valadoc_gtkdoc_markdown_parser_parse_note (self, _tmp11_);
		note = _tmp12_;
		_tmp13_ = note;
		valadoc_gtkdoc_markdown_parser_add_note (self, &cmnt, _tmp13_);
		_g_object_unref0 (note);
	}
	_tmp14_ = valadoc_api_gir_source_comment_get_version_comment (gir_comment);
	_tmp15_ = _tmp14_;
	if (_tmp15_ != NULL) {
		ValadocContentNote* note = NULL;
		ValadocApiSourceComment* _tmp16_;
		ValadocApiSourceComment* _tmp17_;
		ValadocContentNote* _tmp18_;
		ValadocContentNote* _tmp19_;
		_tmp16_ = valadoc_api_gir_source_comment_get_version_comment (gir_comment);
		_tmp17_ = _tmp16_;
		_tmp18_ = _valadoc_gtkdoc_markdown_parser_parse_note (self, _tmp17_);
		note = _tmp18_;
		_tmp19_ = note;
		valadoc_gtkdoc_markdown_parser_add_note (self, &cmnt, _tmp19_);
		_g_object_unref0 (note);
	}
	_tmp20_ = valadoc_api_gir_source_comment_get_stability_comment (gir_comment);
	_tmp21_ = _tmp20_;
	if (_tmp21_ != NULL) {
		ValadocContentNote* note = NULL;
		ValadocApiSourceComment* _tmp22_;
		ValadocApiSourceComment* _tmp23_;
		ValadocContentNote* _tmp24_;
		ValadocContentNote* _tmp25_;
		_tmp22_ = valadoc_api_gir_source_comment_get_stability_comment (gir_comment);
		_tmp23_ = _tmp22_;
		_tmp24_ = _valadoc_gtkdoc_markdown_parser_parse_note (self, _tmp23_);
		note = _tmp24_;
		_tmp25_ = note;
		valadoc_gtkdoc_markdown_parser_add_note (self, &cmnt, _tmp25_);
		_g_object_unref0 (note);
	}
	_tmp26_ = valadoc_api_gir_source_comment_get_return_comment (gir_comment);
	_tmp27_ = _tmp26_;
	if (_tmp27_ != NULL) {
		ValadocContentTaglet* taglet = NULL;
		ValadocApiSourceComment* _tmp28_;
		ValadocApiSourceComment* _tmp29_;
		ValadocContentTaglet* _tmp30_;
		ValadocContentTaglet* _tmp31_;
		_tmp28_ = valadoc_api_gir_source_comment_get_return_comment (gir_comment);
		_tmp29_ = _tmp28_;
		_tmp30_ = _valadoc_gtkdoc_markdown_parser_parse_block_taglet (self, _tmp29_, "return");
		taglet = _tmp30_;
		_tmp31_ = taglet;
		valadoc_gtkdoc_markdown_parser_add_taglet (self, &cmnt, _tmp31_);
		_g_object_unref0 (taglet);
	}
	_tmp32_ = valadoc_api_gir_source_comment_parameter_iterator (gir_comment);
	iter = _tmp32_;
	{
		gboolean has_next = FALSE;
		ValaMapIterator* _tmp33_;
		_tmp33_ = iter;
		has_next = vala_map_iterator_next (_tmp33_);
		{
			gboolean _tmp34_ = FALSE;
			_tmp34_ = TRUE;
			while (TRUE) {
				ValadocTagletsParam* taglet = NULL;
				ValaMapIterator* _tmp36_;
				gpointer _tmp37_;
				ValadocApiSourceComment* _tmp38_;
				ValadocContentTaglet* _tmp39_;
				ValadocTagletsParam* _tmp40_;
				ValadocTagletsParam* _tmp41_;
				gchar* param_name = NULL;
				ValaMapIterator* _tmp42_;
				gpointer _tmp43_;
				ValadocTagletsParam* _tmp44_;
				const gchar* _tmp45_;
				const gchar* _tmp46_;
				const gchar* _tmp47_;
				ValadocTagletsParam* _tmp48_;
				const gchar* _tmp49_;
				ValadocTagletsParam* _tmp50_;
				if (!_tmp34_) {
					ValaMapIterator* _tmp35_;
					_tmp35_ = iter;
					has_next = vala_map_iterator_next (_tmp35_);
				}
				_tmp34_ = FALSE;
				if (!has_next) {
					break;
				}
				_tmp36_ = iter;
				_tmp37_ = vala_map_iterator_get_value (_tmp36_);
				_tmp38_ = (ValadocApiSourceComment*) _tmp37_;
				_tmp39_ = _valadoc_gtkdoc_markdown_parser_parse_block_taglet (self, _tmp38_, "param");
				_tmp40_ = VALADOC_TAGLETS_IS_PARAM (_tmp39_) ? ((ValadocTagletsParam*) _tmp39_) : NULL;
				if (_tmp40_ == NULL) {
					_g_object_unref0 (_tmp39_);
				}
				_tmp41_ = _tmp40_;
				_valadoc_api_source_comment_unref0 (_tmp38_);
				taglet = _tmp41_;
				_tmp42_ = iter;
				_tmp43_ = vala_map_iterator_get_key (_tmp42_);
				param_name = (gchar*) _tmp43_;
				_tmp44_ = taglet;
				_tmp45_ = param_name;
				_tmp46_ = valadoc_api_gir_source_comment_get_instance_param_name (gir_comment);
				_tmp47_ = _tmp46_;
				valadoc_taglets_param_set_is_c_self_param (_tmp44_, g_strcmp0 (_tmp45_, _tmp47_) == 0);
				_tmp48_ = taglet;
				_tmp49_ = param_name;
				valadoc_taglets_param_set_parameter_name (_tmp48_, _tmp49_);
				_tmp50_ = taglet;
				valadoc_gtkdoc_markdown_parser_add_taglet (self, &cmnt, (ValadocContentTaglet*) _tmp50_);
				_g_free0 (param_name);
				_g_object_unref0 (taglet);
			}
		}
	}
	_g_object_unref0 (self->priv->metadata);
	self->priv->metadata = NULL;
	_valadoc_api_source_comment_unref0 (self->priv->gir_comment);
	self->priv->gir_comment = NULL;
	_valadoc_importer_internal_id_registrar_unref0 (self->priv->id_registrar);
	self->priv->id_registrar = NULL;
	_g_object_unref0 (self->priv->element);
	self->priv->element = NULL;
	result = cmnt;
	_vala_map_iterator_unref0 (iter);
	return result;
}

static void
valadoc_gtkdoc_markdown_parser_add_text (ValadocGtkdocMarkdownParser* self,
                                         ValadocToken* token,
                                         GError** error)
{
	const gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (token != NULL);
	_tmp0_ = valadoc_token_to_string (token);
	valadoc_gtkdoc_markdown_parser_add_content_string (self, _tmp0_);
}

static void
valadoc_gtkdoc_markdown_parser_add_value (ValadocGtkdocMarkdownParser* self,
                                          ValadocToken* token,
                                          GError** error)
{
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (token != NULL);
	_tmp0_ = valadoc_token_get_value (token);
	_tmp1_ = _tmp0_;
	_vala_assert (_tmp1_ != NULL, "token.value != null");
	_tmp2_ = valadoc_token_get_value (token);
	_tmp3_ = _tmp2_;
	valadoc_gtkdoc_markdown_parser_add_content_string (self, _tmp3_);
}

static void
valadoc_gtkdoc_markdown_parser_add_content_string (ValadocGtkdocMarkdownParser* self,
                                                   const gchar* str)
{
	ValadocContentText* text = NULL;
	GObject* _tmp0_;
	ValadocContentText* _tmp1_;
	ValadocContentText* _tmp2_;
	ValadocContentText* _tmp6_;
	ValadocContentText* _tmp7_;
	const gchar* _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (str != NULL);
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	_tmp1_ = VALADOC_CONTENT_IS_TEXT (_tmp0_) ? ((ValadocContentText*) _tmp0_) : NULL;
	if (_tmp1_ == NULL) {
		_g_object_unref0 (_tmp0_);
	}
	text = _tmp1_;
	_tmp2_ = text;
	if (_tmp2_ == NULL) {
		ValadocContentContentFactory* _tmp3_;
		ValadocContentText* _tmp4_;
		ValadocContentText* _tmp5_;
		_tmp3_ = self->priv->_factory;
		_tmp4_ = valadoc_content_content_factory_create_text (_tmp3_, NULL);
		_g_object_unref0 (text);
		text = _tmp4_;
		_tmp5_ = text;
		valadoc_gtkdoc_markdown_parser_push (self, (GObject*) _tmp5_);
	}
	_tmp6_ = text;
	_tmp7_ = text;
	_tmp8_ = valadoc_content_text_get_content (_tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = g_strconcat (_tmp9_, str, NULL);
	_tmp11_ = _tmp10_;
	valadoc_content_text_set_content (_tmp7_, _tmp11_);
	_g_free0 (_tmp11_);
	_g_object_unref0 (text);
}

static void
valadoc_gtkdoc_markdown_parser_add_symbol_link (ValadocGtkdocMarkdownParser* self,
                                                const gchar* symbol,
                                                gboolean accept_plural)
{
	ValadocTagletsLink* taglet = NULL;
	ValadocTagletsLink* _tmp0_;
	ValadocContentRun* run = NULL;
	ValadocContentContentFactory* _tmp1_;
	ValadocContentRun* _tmp2_;
	ValaList* _tmp3_;
	ValaList* _tmp4_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (symbol != NULL);
	_tmp0_ = valadoc_taglets_link_new ();
	taglet = _tmp0_;
	valadoc_taglets_link_set_c_accept_plural (taglet, accept_plural);
	valadoc_taglets_link_set_symbol_name (taglet, symbol);
	_tmp1_ = self->priv->_factory;
	_tmp2_ = valadoc_content_content_factory_create_run (_tmp1_, VALADOC_CONTENT_RUN_STYLE_NONE);
	run = _tmp2_;
	_tmp3_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) run);
	_tmp4_ = _tmp3_;
	vala_collection_add ((ValaCollection*) _tmp4_, (ValadocContentInline*) taglet);
	valadoc_gtkdoc_markdown_parser_push (self, (GObject*) run);
	_g_object_unref0 (run);
	_g_object_unref0 (taglet);
}

static void
valadoc_gtkdoc_markdown_parser_preserve_token (ValadocGtkdocMarkdownParser* self,
                                               ValadocToken* token,
                                               GError** error)
{
	ValadocToken* _tmp0_;
	ValadocToken* _tmp1_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (token != NULL);
	_tmp0_ = self->priv->preserved_token;
	_vala_assert (_tmp0_ == NULL, "preserved_token == null");
	_tmp1_ = _g_object_ref0 (token);
	_g_object_unref0 (self->priv->preserved_token);
	self->priv->preserved_token = _tmp1_;
}

static gchar*
valadoc_gtkdoc_markdown_parser_pop_preserved_link (ValadocGtkdocMarkdownParser* self)
{
	ValadocToken* _tmp0_;
	ValadocToken* _link_token = NULL;
	ValadocToken* _tmp1_;
	ValadocToken* _tmp2_;
	ValadocTokenType* _tmp3_;
	ValadocTokenType* _tmp4_;
	ValadocTokenType* _tmp5_;
	ValadocToken* _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	ValadocToken* _tmp17_;
	const gchar* _tmp18_;
	const gchar* _tmp19_;
	gchar* _tmp20_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->preserved_token;
	_vala_assert (_tmp0_ != NULL, "preserved_token != null");
	_tmp1_ = self->priv->preserved_token;
	self->priv->preserved_token = NULL;
	_link_token = _tmp1_;
	_tmp2_ = _link_token;
	_tmp3_ = valadoc_token_get_token_type (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = valadoc_token_type_MARKDOWN_MAIL;
	if (_tmp4_ == _tmp5_) {
		ValadocToken* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		gchar* _tmp9_;
		_tmp6_ = _link_token;
		_tmp7_ = valadoc_token_get_value (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = g_strconcat ("mailto:", _tmp8_, NULL);
		result = _tmp9_;
		_g_object_unref0 (_link_token);
		return result;
	}
	_tmp10_ = _link_token;
	_tmp11_ = valadoc_token_get_value (_tmp10_);
	_tmp12_ = _tmp11_;
	if (_tmp12_ != NULL) {
		ValadocToken* _tmp13_;
		const gchar* _tmp14_;
		const gchar* _tmp15_;
		gchar* _tmp16_;
		_tmp13_ = _link_token;
		_tmp14_ = valadoc_token_get_value (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = g_strdup (_tmp15_);
		result = _tmp16_;
		_g_object_unref0 (_link_token);
		return result;
	}
	_tmp17_ = _link_token;
	_tmp18_ = valadoc_token_get_word (_tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = g_strdup (_tmp19_);
	result = _tmp20_;
	_g_object_unref0 (_link_token);
	return result;
}

static gchar*
valadoc_gtkdoc_markdown_parser_pop_preserved_path (ValadocGtkdocMarkdownParser* self)
{
	ValadocToken* _tmp0_;
	ValadocToken* _path_token = NULL;
	ValadocToken* _tmp1_;
	const gchar* _tmp2_ = NULL;
	ValadocToken* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	gchar* _tmp9_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->preserved_token;
	_vala_assert (_tmp0_ != NULL, "preserved_token != null");
	_tmp1_ = self->priv->preserved_token;
	self->priv->preserved_token = NULL;
	_path_token = _tmp1_;
	_tmp3_ = _path_token;
	_tmp4_ = valadoc_token_get_word (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp2_ = _tmp5_;
	if (_tmp2_ == NULL) {
		ValadocToken* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		_tmp6_ = _path_token;
		_tmp7_ = valadoc_token_get_value (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp2_ = _tmp8_;
	}
	_tmp9_ = g_strdup (_tmp2_);
	result = _tmp9_;
	_g_object_unref0 (_path_token);
	return result;
}

static inline gchar*
valadoc_gtkdoc_markdown_parser_run_to_string (ValadocGtkdocMarkdownParser* self,
                                              ValadocContentRun* run,
                                              const gchar* rule_name,
                                              GError** error)
{
	GString* builder = NULL;
	GString* _tmp0_;
	gchar* _tmp1_;
	GError* _inner_error0_ = NULL;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (run != NULL, NULL);
	g_return_val_if_fail (rule_name != NULL, NULL);
	_tmp0_ = g_string_new ("");
	builder = _tmp0_;
	valadoc_gtkdoc_markdown_parser_inline_to_string (self, (ValadocContentInline*) run, rule_name, builder, &_inner_error0_);
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		g_propagate_error (error, _inner_error0_);
		_g_string_free0 (builder);
		return NULL;
	}
	_tmp1_ = builder->str;
	builder->str = NULL;
	result = _tmp1_;
	_g_string_free0 (builder);
	return result;
}

static void
valadoc_gtkdoc_markdown_parser_inline_to_string (ValadocGtkdocMarkdownParser* self,
                                                 ValadocContentInline* element,
                                                 const gchar* rule_name,
                                                 GString* builder,
                                                 GError** error)
{
	GError* _inner_error0_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (element != NULL);
	g_return_if_fail (rule_name != NULL);
	if (VALADOC_CONTENT_IS_RUN (element)) {
		ValadocContentRun* run = NULL;
		ValadocContentRun* _tmp0_;
		_tmp0_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (element, VALADOC_CONTENT_TYPE_RUN, ValadocContentRun));
		run = _tmp0_;
		{
			ValaList* _item_list = NULL;
			ValadocContentRun* _tmp1_;
			ValaList* _tmp2_;
			ValaList* _tmp3_;
			gint _item_size = 0;
			ValaList* _tmp4_;
			gint _tmp5_;
			gint _tmp6_;
			gint _item_index = 0;
			_tmp1_ = run;
			_tmp2_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp1_);
			_tmp3_ = _tmp2_;
			_item_list = _tmp3_;
			_tmp4_ = _item_list;
			_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
			_tmp6_ = _tmp5_;
			_item_size = _tmp6_;
			_item_index = -1;
			while (TRUE) {
				gint _tmp7_;
				gint _tmp8_;
				ValadocContentInline* item = NULL;
				ValaList* _tmp9_;
				gpointer _tmp10_;
				ValadocContentInline* _tmp11_;
				_item_index = _item_index + 1;
				_tmp7_ = _item_index;
				_tmp8_ = _item_size;
				if (!(_tmp7_ < _tmp8_)) {
					break;
				}
				_tmp9_ = _item_list;
				_tmp10_ = vala_list_get (_tmp9_, _item_index);
				item = (ValadocContentInline*) _tmp10_;
				_tmp11_ = item;
				valadoc_gtkdoc_markdown_parser_inline_to_string (self, _tmp11_, rule_name, builder, &_inner_error0_);
				if (G_UNLIKELY (_inner_error0_ != NULL)) {
					g_propagate_error (error, _inner_error0_);
					_g_object_unref0 (item);
					_g_object_unref0 (run);
					return;
				}
				_g_object_unref0 (item);
			}
		}
		_g_object_unref0 (run);
	} else {
		if (VALADOC_CONTENT_IS_TEXT (element)) {
			ValadocContentText* text = NULL;
			ValadocContentText* _tmp12_;
			ValadocContentText* _tmp13_;
			const gchar* _tmp14_;
			const gchar* _tmp15_;
			_tmp12_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (element, VALADOC_CONTENT_TYPE_TEXT, ValadocContentText));
			text = _tmp12_;
			_tmp13_ = text;
			_tmp14_ = valadoc_content_text_get_content (_tmp13_);
			_tmp15_ = _tmp14_;
			g_string_append (builder, _tmp15_);
			_g_object_unref0 (text);
		} else {
			if (VALADOC_CONTENT_IS_EMBEDDED (element)) {
				GError* _tmp16_;
				_tmp16_ = g_error_new (VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR, VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR_UNEXPECTED_ELEMENT, "Unexpected tag: <image> in `%s'", rule_name);
				_inner_error0_ = _tmp16_;
				g_propagate_error (error, _inner_error0_);
				return;
			} else {
				if (VALADOC_CONTENT_IS_LINK (element)) {
					GError* _tmp17_;
					_tmp17_ = g_error_new (VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR, VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR_UNEXPECTED_ELEMENT, "Unexpected tag: <link> in `%s'", rule_name);
					_inner_error0_ = _tmp17_;
					g_propagate_error (error, _inner_error0_);
					return;
				} else {
					if (VALADOC_CONTENT_IS_SOURCE_CODE (element)) {
						GError* _tmp18_;
						_tmp18_ = g_error_new (VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR, VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR_UNEXPECTED_ELEMENT, "Unexpected tag: `|[' in `%s'", rule_name);
						_inner_error0_ = _tmp18_;
						g_propagate_error (error, _inner_error0_);
						return;
					} else {
						GError* _tmp19_;
						_tmp19_ = g_error_new (VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR, VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR_UNEXPECTED_ELEMENT, "Unexpected tag in `%s''", rule_name);
						_inner_error0_ = _tmp19_;
						g_propagate_error (error, _inner_error0_);
						return;
					}
				}
			}
		}
	}
}

static gchar
string_get (const gchar* self,
            glong index)
{
	gchar _tmp0_;
	gchar result;
	g_return_val_if_fail (self != NULL, '\0');
	_tmp0_ = ((gchar*) self)[index];
	result = _tmp0_;
	return result;
}

static gboolean
valadoc_gtkdoc_markdown_parser_is_literal (ValadocGtkdocMarkdownParser* self,
                                           const gchar* str)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (str != NULL, FALSE);
	if (g_strcmp0 (str, "TRUE") == 0) {
		result = TRUE;
		return result;
	}
	if (g_strcmp0 (str, "FALSE") == 0) {
		result = TRUE;
		return result;
	}
	if (g_strcmp0 (str, "NULL") == 0) {
		result = TRUE;
		return result;
	}
	if (g_ascii_isdigit (string_get (str, (glong) 0))) {
		result = TRUE;
		return result;
	}
	result = TRUE;
	return result;
}

static gboolean
valadoc_gtkdoc_markdown_parser_is_error_parameter (ValadocGtkdocMarkdownParser* self,
                                                   const gchar* name)
{
	gboolean _tmp0_ = FALSE;
	ValadocApiNode* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValadocApiNode* _tmp3_;
	ValadocApiNode* _tmp5_;
	ValadocApiNodeType* _tmp6_;
	ValadocApiNodeType* _tmp7_;
	gint _tmp7__length1;
	ValaList* _tmp8_;
	ValaList* _tmp9_;
	gint _tmp10_;
	gint _tmp11_;
	gboolean _tmp12_;
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (name != NULL, FALSE);
	_tmp1_ = self->priv->element;
	if (_tmp1_ == NULL) {
		_tmp0_ = TRUE;
	} else {
		_tmp0_ = g_strcmp0 (name, "error") != 0;
	}
	if (_tmp0_) {
		result = FALSE;
		return result;
	}
	_tmp3_ = self->priv->element;
	if (VALADOC_API_IS_METHOD (_tmp3_)) {
		_tmp2_ = TRUE;
	} else {
		ValadocApiNode* _tmp4_;
		_tmp4_ = self->priv->element;
		_tmp2_ = VALADOC_API_IS_DELEGATE (_tmp4_);
	}
	if (!_tmp2_) {
		result = FALSE;
		return result;
	}
	_tmp5_ = self->priv->element;
	_tmp6_ = g_new0 (ValadocApiNodeType, 2);
	_tmp6_[0] = VALADOC_API_NODE_TYPE_ERROR_DOMAIN;
	_tmp6_[1] = VALADOC_API_NODE_TYPE_CLASS;
	_tmp7_ = _tmp6_;
	_tmp7__length1 = 2;
	_tmp8_ = valadoc_api_node_get_children_by_types (_tmp5_, _tmp7_, (gint) 2, TRUE);
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = _tmp11_ > 0;
	_vala_iterable_unref0 (_tmp9_);
	_tmp7_ = (g_free (_tmp7_), NULL);
	result = _tmp12_;
	return result;
}

static gchar*
valadoc_gtkdoc_markdown_parser_real_resolve (ValadocResourceLocator* base,
                                             const gchar* path)
{
	ValadocGtkdocMarkdownParser * self;
	gchar* _tmp0_;
	gchar* result;
	self = (ValadocGtkdocMarkdownParser*) base;
	g_return_val_if_fail (path != NULL, NULL);
	_tmp0_ = g_strdup (path);
	result = _tmp0_;
	return result;
}

static void
valadoc_gtkdoc_markdown_parser_push (ValadocGtkdocMarkdownParser* self,
                                     GObject* element)
{
	ValaArrayList* _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (element != NULL);
	_tmp0_ = self->priv->_stack;
	vala_collection_add ((ValaCollection*) _tmp0_, element);
}

static GObject*
valadoc_gtkdoc_markdown_parser_peek (ValadocGtkdocMarkdownParser* self,
                                     gint offset)
{
	ValaArrayList* _tmp0_;
	gint _tmp1_;
	gint _tmp2_;
	ValaArrayList* _tmp3_;
	ValaArrayList* _tmp4_;
	gint _tmp5_;
	gint _tmp6_;
	gpointer _tmp7_;
	GObject* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_stack;
	_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
	_tmp2_ = _tmp1_;
	_vala_assert (_tmp2_ >= (-offset), "_stack.size >= - offset");
	_tmp3_ = self->priv->_stack;
	_tmp4_ = self->priv->_stack;
	_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = vala_list_get ((ValaList*) _tmp3_, _tmp6_ + offset);
	result = (GObject*) _tmp7_;
	return result;
}

static GObject*
valadoc_gtkdoc_markdown_parser_pop (ValadocGtkdocMarkdownParser* self)
{
	GObject* node = NULL;
	GObject* _tmp0_;
	ValaArrayList* _tmp1_;
	ValaArrayList* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gpointer _tmp5_;
	GObject* _tmp6_;
	GObject* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = valadoc_gtkdoc_markdown_parser_peek (self, -1);
	node = _tmp0_;
	_tmp1_ = self->priv->_stack;
	_tmp2_ = self->priv->_stack;
	_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_list_remove_at ((ValaList*) _tmp1_, _tmp4_ - 1);
	_tmp6_ = (GObject*) _tmp5_;
	_g_object_unref0 (_tmp6_);
	result = node;
	return result;
}

static inline gchar*
valadoc_gtkdoc_markdown_parser_fix_resource_path (ValadocGtkdocMarkdownParser* self,
                                                  const gchar* path)
{
	ValadocGirMetaData* _tmp0_;
	gchar* _tmp1_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (path != NULL, NULL);
	_tmp0_ = self->priv->metadata;
	_tmp1_ = valadoc_gir_meta_data_get_resource_path (_tmp0_, path);
	result = _tmp1_;
	return result;
}

static void
valadoc_gtkdoc_markdown_parser_class_init (ValadocGtkdocMarkdownParserClass * klass,
                                           gpointer klass_data)
{
	valadoc_gtkdoc_markdown_parser_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ValadocGtkdocMarkdownParser_private_offset);
	G_OBJECT_CLASS (klass)->finalize = valadoc_gtkdoc_markdown_parser_finalize;
}

static void
valadoc_gtkdoc_markdown_parser_valadoc_resource_locator_interface_init (ValadocResourceLocatorIface * iface,
                                                                        gpointer iface_data)
{
	valadoc_gtkdoc_markdown_parser_valadoc_resource_locator_parent_iface = g_type_interface_peek_parent (iface);
	iface->resolve = (gchar* (*) (ValadocResourceLocator*, const gchar*)) valadoc_gtkdoc_markdown_parser_real_resolve;
}

static void
valadoc_gtkdoc_markdown_parser_instance_init (ValadocGtkdocMarkdownParser * self,
                                              gpointer klass)
{
	GEqualFunc _tmp0_;
	ValaArrayList* _tmp1_;
	self->priv = valadoc_gtkdoc_markdown_parser_get_instance_private (self);
	_tmp0_ = g_direct_equal;
	_tmp1_ = vala_array_list_new (G_TYPE_OBJECT, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp0_);
	self->priv->_stack = _tmp1_;
	self->priv->preserved_token = NULL;
}

static void
valadoc_gtkdoc_markdown_parser_finalize (GObject * obj)
{
	ValadocGtkdocMarkdownParser * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_GTKDOC_TYPE_MARKDOWN_PARSER, ValadocGtkdocMarkdownParser);
	_valadoc_parser_unref0 (self->priv->parser);
	_g_object_unref0 (self->priv->_factory);
	_g_object_unref0 (self->priv->_settings);
	_g_object_unref0 (self->priv->_reporter);
	_valadoc_api_tree_unref0 (self->priv->_tree);
	_vala_iterable_unref0 (self->priv->_stack);
	_g_object_unref0 (self->priv->preserved_token);
	_g_regex_unref0 (self->priv->regex_source_lang);
	_valadoc_importer_internal_id_registrar_unref0 (self->priv->id_registrar);
	_g_object_unref0 (self->priv->metadata);
	_valadoc_api_source_comment_unref0 (self->priv->gir_comment);
	_g_object_unref0 (self->priv->element);
	G_OBJECT_CLASS (valadoc_gtkdoc_markdown_parser_parent_class)->finalize (obj);
}

static GType
valadoc_gtkdoc_markdown_parser_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ValadocGtkdocMarkdownParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_gtkdoc_markdown_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocGtkdocMarkdownParser), 0, (GInstanceInitFunc) valadoc_gtkdoc_markdown_parser_instance_init, NULL };
	static const GInterfaceInfo valadoc_resource_locator_info = { (GInterfaceInitFunc) valadoc_gtkdoc_markdown_parser_valadoc_resource_locator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	GType valadoc_gtkdoc_markdown_parser_type_id;
	valadoc_gtkdoc_markdown_parser_type_id = g_type_register_static (G_TYPE_OBJECT, "ValadocGtkdocMarkdownParser", &g_define_type_info, 0);
	g_type_add_interface_static (valadoc_gtkdoc_markdown_parser_type_id, VALADOC_TYPE_RESOURCE_LOCATOR, &valadoc_resource_locator_info);
	ValadocGtkdocMarkdownParser_private_offset = g_type_add_instance_private (valadoc_gtkdoc_markdown_parser_type_id, sizeof (ValadocGtkdocMarkdownParserPrivate));
	return valadoc_gtkdoc_markdown_parser_type_id;
}

GType
valadoc_gtkdoc_markdown_parser_get_type (void)
{
	static volatile gsize valadoc_gtkdoc_markdown_parser_type_id__once = 0;
	if (g_once_init_enter (&valadoc_gtkdoc_markdown_parser_type_id__once)) {
		GType valadoc_gtkdoc_markdown_parser_type_id;
		valadoc_gtkdoc_markdown_parser_type_id = valadoc_gtkdoc_markdown_parser_get_type_once ();
		g_once_init_leave (&valadoc_gtkdoc_markdown_parser_type_id__once, valadoc_gtkdoc_markdown_parser_type_id);
	}
	return valadoc_gtkdoc_markdown_parser_type_id__once;
}

GQuark
valadoc_gtkdoc_content_to_string_error_quark (void)
{
	return g_quark_from_static_string ("valadoc-gtkdoc-content-to-string-error-quark");
}

static GType
valadoc_gtkdoc_content_to_string_error_get_type_once (void)
{
	static const GEnumValue values[] = {{VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR_UNEXPECTED_ELEMENT, "VALADOC_GTKDOC_CONTENT_TO_STRING_ERROR_UNEXPECTED_ELEMENT", "unexpected-element"}, {0, NULL, NULL}};
	GType valadoc_gtkdoc_content_to_string_error_type_id;
	valadoc_gtkdoc_content_to_string_error_type_id = g_enum_register_static ("ValadocGtkdocContentToStringError", values);
	return valadoc_gtkdoc_content_to_string_error_type_id;
}

 G_GNUC_INTERNAL GType
valadoc_gtkdoc_content_to_string_error_get_type (void)
{
	static volatile gsize valadoc_gtkdoc_content_to_string_error_type_id__once = 0;
	if (g_once_init_enter (&valadoc_gtkdoc_content_to_string_error_type_id__once)) {
		GType valadoc_gtkdoc_content_to_string_error_type_id;
		valadoc_gtkdoc_content_to_string_error_type_id = valadoc_gtkdoc_content_to_string_error_get_type_once ();
		g_once_init_leave (&valadoc_gtkdoc_content_to_string_error_type_id__once, valadoc_gtkdoc_content_to_string_error_type_id);
	}
	return valadoc_gtkdoc_content_to_string_error_type_id__once;
}

static void
_vala_array_destroy (gpointer array,
                     gssize array_length,
                     GDestroyNotify destroy_func)
{
	if ((array != NULL) && (destroy_func != NULL)) {
		gssize i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}

static void
_vala_array_free (gpointer array,
                  gssize array_length,
                  GDestroyNotify destroy_func)
{
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}