monoeg_g_markup_parse_context_new (const struct GMarkupParser * parser, GMarkupParseFlags flags, void * user_data, void (*GDestroyNotify) (void *) user_data_dnotify)
{
  struct GMarkupParseContext * D.4704;
  struct GMarkupParseContext * context;

  context = monoeg_malloc0 (40);
  context->parser = *parser;
  context->user_data = user_data;
  context->user_data_dnotify = user_data_dnotify;
  D.4704 = context;
  return D.4704;
}


monoeg_g_markup_parse_context_free (struct GMarkupParseContext * context)
{
  void (*<Tb02>) (void *) D.4708;
  void * D.4711;
  struct GString * D.4712;
  void * D.4715;
  struct GSList * D.4716;
  struct GSList * l;

  if (context == 0B) goto <D.4706>; else goto <D.4707>;
  <D.4706>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 90, "context != NULL");
  return;
  <D.4707>:
  D.4708 = context->user_data_dnotify;
  if (D.4708 != 0B) goto <D.4709>; else goto <D.4710>;
  <D.4709>:
  D.4708 = context->user_data_dnotify;
  D.4711 = context->user_data;
  D.4708 (D.4711);
  <D.4710>:
  D.4712 = context->text;
  if (D.4712 != 0B) goto <D.4713>; else goto <D.4714>;
  <D.4713>:
  D.4712 = context->text;
  monoeg_g_string_free (D.4712, 1);
  <D.4714>:
  l = context->level;
  goto <D.4597>;
  <D.4596>:
  D.4715 = l->data;
  monoeg_g_free (D.4715);
  l = l->next;
  <D.4597>:
  if (l != 0B) goto <D.4596>; else goto <D.4598>;
  <D.4598>:
  D.4716 = context->level;
  monoeg_g_slist_free (D.4716);
  monoeg_g_free (context);
}


monoeg_g_markup_parse_context_parse (struct GMarkupParseContext * context, const gchar * text, gssize text_len, struct GError * * error)
{
  gboolean D.4720;
  sizetype text_len.0;
  <unnamed type> D.4726;
  _Bool D.4729;
  _Bool D.4730;
  _Bool D.4731;
  _Bool D.4733;
  _Bool D.4734;
  _Bool D.4735;
  const char * D.4741;
  char D.4743;
  struct GError * D.4747;
  char D.4749;
  int D.4750;
  int D.4751;
  struct GError * D.4756;
  const char * D.4759;
  char D.4764;
  int D.4767;
  struct GError * D.4772;
  int D.4774;
  struct GError * D.4780;
  int D.4782;
  struct GError * D.4787;
  int D.4788;
  gchar * * names.1;
  gchar * * values.2;
  struct GError * D.4797;
  struct GError * D.4802;
  int element_end.3;
  int element_start.4;
  int D.4805;
  unsigned int D.4806;
  unsigned int l.5;
  sizetype l.6;
  char * D.4810;
  void (*<Td6b>) (struct GMarkupParseContext *, const gchar *, const gchar * *, const gchar * *, void *, struct GError * *) D.4813;
  void * D.4816;
  int full_stop.7;
  void (*<Td6f>) (struct GMarkupParseContext *, const gchar *, void *, struct GError * *) D.4826;
  struct GSList * D.4836;
  struct GSList * D.4837;
  void (*<Td73>) (struct GMarkupParseContext *, const gchar *, gsize, void *, struct GError * *) D.4840;
  struct GString * D.4843;
  struct GString * D.4846;
  int D.4847;
  unsigned int D.4859;
  char * D.4860;
  struct GError * D.4871;
  struct GSList * D.4879;
  void (*<Td79>) (struct GMarkupParseContext *, struct GError *, void *) D.4881;
  const char * p;
  const char * end;
  void fail = <<< error >>>;

  if (context == 0B) goto <D.4718>; else goto <D.4719>;
  <D.4718>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 268, "context != NULL");
  D.4720 = 0;
  return D.4720;
  <D.4719>:
  if (text == 0B) goto <D.4721>; else goto <D.4722>;
  <D.4721>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 269, "text != NULL");
  D.4720 = 0;
  return D.4720;
  <D.4722>:
  if (text_len < 0) goto <D.4723>; else goto <D.4724>;
  <D.4723>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 270, "text_len >= 0");
  D.4720 = 0;
  return D.4720;
  <D.4724>:
  text_len.0 = (sizetype) text_len;
  end = text + text_len.0;
  p = text;
  goto <D.4697>;
  <D.4696>:
  {
    char c;

    c = *p;
    D.4726 = context->state;
    switch (D.4726) <default: <D.4880>, case 0: <D.4665>, case 1: <D.4669>, case 2: <D.4687>, case 3: <D.4689>, case 4: <D.4690>, case 5: <D.4688>, case 6: <D.4668>>
    <D.4665>:
    D.4729 = c == 32;
    D.4730 = c == 9;
    D.4731 = D.4729 | D.4730;
    if (D.4731 != 0) goto <D.4727>; else goto <D.4732>;
    <D.4732>:
    D.4733 = c == 12;
    D.4734 = c == 10;
    D.4735 = D.4733 | D.4734;
    if (D.4735 != 0) goto <D.4727>; else goto <D.4736>;
    <D.4736>:
    if (c < 0) goto <D.4727>; else goto <D.4728>;
    <D.4727>:
    // predicted unlikely by continue predictor.
    goto <D.4666>;
    <D.4728>:
    if (c == 60) goto <D.4737>; else goto <D.4738>;
    <D.4737>:
    D.4741 = p + 1;
    if (D.4741 < end) goto <D.4742>; else goto <D.4739>;
    <D.4742>:
    D.4741 = p + 1;
    D.4743 = *D.4741;
    if (D.4743 == 63) goto <D.4744>; else goto <D.4739>;
    <D.4744>:
    context->state = 6;
    p = p + 1;
    goto <D.4740>;
    <D.4739>:
    context->state = 1;
    <D.4740>:
    // predicted unlikely by continue predictor.
    goto <D.4666>;
    <D.4738>:
    if (error != 0B) goto <D.4745>; else goto <D.4746>;
    <D.4745>:
    D.4747 = monoeg_g_error_new (1B, 1, "%s", "Expected < to start the document");
    *error = D.4747;
    <D.4746>:
    goto fail;
    <D.4668>:
    <D.4669>:
    {
      const char * element_start;
      const char * element_end;
      char * ename;
      int full_stop;
      int l;
      gchar * * names;
      gchar * * values;

      try
        {
          element_start = p;
          ename = 0B;
          full_stop = 0;
          names = 0B;
          values = 0B;
          goto <D.4678>;
          <D.4677>:
          p = p + 1;
          <D.4678>:
          if (p < end) goto <D.4748>; else goto <D.4679>;
          <D.4748>:
          D.4749 = *p;
          D.4750 = (int) D.4749;
          D.4751 = my_isspace (D.4750);
          if (D.4751 != 0) goto <D.4677>; else goto <D.4679>;
          <D.4679>:
          if (p == end) goto <D.4752>; else goto <D.4753>;
          <D.4752>:
          if (error != 0B) goto <D.4754>; else goto <D.4755>;
          <D.4754>:
          D.4756 = monoeg_g_error_new (1B, 1, "%s", "Unfinished element");
          *error = D.4756;
          <D.4755>:
          goto fail;
          <D.4753>:
          D.4749 = *p;
          if (D.4749 == 33) goto <D.4757>; else goto <D.4758>;
          <D.4757>:
          D.4759 = p + 2;
          if (D.4759 < end) goto <D.4760>; else goto <D.4761>;
          <D.4760>:
          D.4741 = p + 1;
          D.4743 = *D.4741;
          if (D.4743 == 45) goto <D.4762>; else goto <D.4763>;
          <D.4762>:
          D.4759 = p + 2;
          D.4764 = *D.4759;
          if (D.4764 == 45) goto <D.4765>; else goto <D.4766>;
          <D.4765>:
          context->state = 5;
          p = p + 2;
          goto <D.4680>;
          <D.4766>:
          <D.4763>:
          <D.4761>:
          <D.4758>:
          D.4749 = *p;
          D.4750 = (int) D.4749;
          D.4767 = my_isalpha (D.4750);
          if (D.4767 == 0) goto <D.4768>; else goto <D.4769>;
          <D.4768>:
          if (error != 0B) goto <D.4770>; else goto <D.4771>;
          <D.4770>:
          D.4772 = monoeg_g_error_new (1B, 1, "%s", "Expected an element name");
          *error = D.4772;
          <D.4771>:
          goto fail;
          <D.4769>:
          p = p + 1;
          goto <D.4682>;
          <D.4681>:
          p = p + 1;
          <D.4682>:
          if (p < end) goto <D.4773>; else goto <D.4683>;
          <D.4773>:
          D.4749 = *p;
          D.4750 = (int) D.4749;
          D.4774 = my_isalnum (D.4750);
          if (D.4774 != 0) goto <D.4681>; else goto <D.4775>;
          <D.4775>:
          D.4749 = *p;
          if (D.4749 == 46) goto <D.4681>; else goto <D.4683>;
          <D.4683>:
          if (p == end) goto <D.4776>; else goto <D.4777>;
          <D.4776>:
          if (error != 0B) goto <D.4778>; else goto <D.4779>;
          <D.4778>:
          D.4780 = monoeg_g_error_new (1B, 1, "%s", "Expected an element");
          *error = D.4780;
          <D.4779>:
          goto fail;
          <D.4777>:
          element_end = p;
          goto <D.4685>;
          <D.4684>:
          p = p + 1;
          <D.4685>:
          if (p < end) goto <D.4781>; else goto <D.4686>;
          <D.4781>:
          D.4749 = *p;
          D.4750 = (int) D.4749;
          D.4782 = my_isspace (D.4750);
          if (D.4782 != 0) goto <D.4684>; else goto <D.4686>;
          <D.4686>:
          if (p == end) goto <D.4783>; else goto <D.4784>;
          <D.4783>:
          if (error != 0B) goto <D.4785>; else goto <D.4786>;
          <D.4785>:
          D.4787 = monoeg_g_error_new (1B, 1, "%s", "Unfinished element");
          *error = D.4787;
          <D.4786>:
          goto fail;
          <D.4784>:
          D.4726 = context->state;
          D.4788 = (int) D.4726;
          p = parse_attributes (p, end, &names, &values, error, &full_stop, D.4788);
          if (p == end) goto <D.4789>; else goto <D.4790>;
          <D.4789>:
          names.1 = names;
          if (names.1 != 0B) goto <D.4792>; else goto <D.4793>;
          <D.4792>:
          names.1 = names;
          monoeg_g_strfreev (names.1);
          values.2 = values;
          monoeg_g_strfreev (values.2);
          <D.4793>:
          if (error != 0B) goto <D.4795>; else goto <D.4796>;
          <D.4795>:
          D.4797 = *error;
          if (D.4797 == 0B) goto <D.4798>; else goto <D.4799>;
          <D.4798>:
          if (error != 0B) goto <D.4800>; else goto <D.4801>;
          <D.4800>:
          D.4802 = monoeg_g_error_new (1B, 1, "%s", "Unfinished sequence");
          *error = D.4802;
          <D.4801>:
          <D.4799>:
          <D.4796>:
          goto fail;
          <D.4790>:
          element_end.3 = (int) element_end;
          element_start.4 = (int) element_start;
          l = element_end.3 - element_start.4;
          D.4805 = l + 1;
          D.4806 = (unsigned int) D.4805;
          ename = monoeg_malloc (D.4806);
          if (ename == 0B) goto fail; else goto <D.4807>;
          <D.4807>:
          l.5 = (unsigned int) l;
          strncpy (ename, element_start, l.5);
          l.6 = (sizetype) l;
          D.4810 = ename + l.6;
          *D.4810 = 0;
          D.4726 = context->state;
          if (D.4726 == 1) goto <D.4811>; else goto <D.4812>;
          <D.4811>:
          D.4813 = context->parser.start_element;
          if (D.4813 != 0B) goto <D.4814>; else goto <D.4815>;
          <D.4814>:
          D.4813 = context->parser.start_element;
          D.4816 = context->user_data;
          values.2 = values;
          names.1 = names;
          D.4813 (context, ename, names.1, values.2, D.4816, error);
          <D.4815>:
          <D.4812>:
          names.1 = names;
          if (names.1 != 0B) goto <D.4817>; else goto <D.4818>;
          <D.4817>:
          names.1 = names;
          monoeg_g_strfreev (names.1);
          values.2 = values;
          monoeg_g_strfreev (values.2);
          <D.4818>:
          if (error != 0B) goto <D.4819>; else goto <D.4820>;
          <D.4819>:
          D.4797 = *error;
          if (D.4797 != 0B) goto <D.4821>; else goto <D.4822>;
          <D.4821>:
          monoeg_g_free (ename);
          goto fail;
          <D.4822>:
          <D.4820>:
          full_stop.7 = full_stop;
          if (full_stop.7 != 0) goto <D.4824>; else goto <D.4825>;
          <D.4824>:
          D.4826 = context->parser.end_element;
          if (D.4826 != 0B) goto <D.4827>; else goto <D.4828>;
          <D.4827>:
          D.4726 = context->state;
          if (D.4726 == 1) goto <D.4829>; else goto <D.4830>;
          <D.4829>:
          D.4826 = context->parser.end_element;
          D.4816 = context->user_data;
          D.4826 (context, ename, D.4816, error);
          if (error != 0B) goto <D.4831>; else goto <D.4832>;
          <D.4831>:
          D.4797 = *error;
          if (D.4797 != 0B) goto <D.4833>; else goto <D.4834>;
          <D.4833>:
          free (ename);
          goto fail;
          <D.4834>:
          <D.4832>:
          <D.4830>:
          <D.4828>:
          monoeg_g_free (ename);
          goto <D.4835>;
          <D.4825>:
          D.4836 = context->level;
          D.4837 = monoeg_g_slist_prepend (D.4836, ename);
          context->level = D.4837;
          <D.4835>:
          context->state = 2;
          goto <D.4680>;
        }
      finally
        {
          full_stop = {CLOBBER};
          names = {CLOBBER};
          values = {CLOBBER};
        }
    }
    <D.4687>:
    if (c == 60) goto <D.4838>; else goto <D.4839>;
    <D.4838>:
    context->state = 3;
    goto <D.4680>;
    <D.4839>:
    D.4840 = context->parser.text;
    if (D.4840 != 0B) goto <D.4841>; else goto <D.4842>;
    <D.4841>:
    D.4843 = context->text;
    if (D.4843 == 0B) goto <D.4844>; else goto <D.4845>;
    <D.4844>:
    D.4846 = monoeg_g_string_new ("");
    context->text = D.4846;
    <D.4845>:
    D.4847 = (int) c;
    D.4843 = context->text;
    monoeg_g_string_append_c (D.4843, D.4847);
    <D.4842>:
    goto <D.4680>;
    <D.4688>:
    D.4749 = *p;
    if (D.4749 != 45) goto <D.4680>; else goto <D.4848>;
    <D.4848>:
    D.4759 = p + 2;
    if (D.4759 < end) goto <D.4849>; else goto <D.4850>;
    <D.4849>:
    D.4741 = p + 1;
    D.4743 = *D.4741;
    if (D.4743 == 45) goto <D.4851>; else goto <D.4852>;
    <D.4851>:
    D.4759 = p + 2;
    D.4764 = *D.4759;
    if (D.4764 == 62) goto <D.4853>; else goto <D.4854>;
    <D.4853>:
    context->state = 2;
    p = p + 2;
    goto <D.4680>;
    <D.4854>:
    <D.4852>:
    <D.4850>:
    goto <D.4680>;
    <D.4689>:
    D.4840 = context->parser.text;
    if (D.4840 != 0B) goto <D.4855>; else goto <D.4856>;
    <D.4855>:
    D.4843 = context->text;
    if (D.4843 != 0B) goto <D.4857>; else goto <D.4858>;
    <D.4857>:
    D.4840 = context->parser.text;
    D.4816 = context->user_data;
    D.4843 = context->text;
    D.4859 = D.4843->len;
    D.4843 = context->text;
    D.4860 = D.4843->str;
    D.4840 (context, D.4860, D.4859, D.4816, error);
    if (error != 0B) goto <D.4861>; else goto <D.4862>;
    <D.4861>:
    D.4797 = *error;
    if (D.4797 != 0B) goto fail; else goto <D.4863>;
    <D.4863>:
    <D.4862>:
    <D.4858>:
    <D.4856>:
    if (c == 47) goto <D.4864>; else goto <D.4865>;
    <D.4864>:
    context->state = 4;
    goto <D.4866>;
    <D.4865>:
    p = p + 4294967295;
    context->state = 1;
    <D.4866>:
    goto <D.4680>;
    <D.4690>:
    {
      struct GSList * current;
      char * text;

      current = context->level;
      D.4836 = context->level;
      if (D.4836 == 0B) goto <D.4867>; else goto <D.4868>;
      <D.4867>:
      if (error != 0B) goto <D.4869>; else goto <D.4870>;
      <D.4869>:
      D.4871 = monoeg_g_error_new (1B, 1, "%s", "Too many closing tags, not enough open tags");
      *error = D.4871;
      <D.4870>:
      goto fail;
      <D.4868>:
      text = current->data;
      D.4826 = context->parser.end_element;
      if (D.4826 != 0B) goto <D.4872>; else goto <D.4873>;
      <D.4872>:
      D.4826 = context->parser.end_element;
      D.4816 = context->user_data;
      D.4826 (context, text, D.4816, error);
      if (error != 0B) goto <D.4874>; else goto <D.4875>;
      <D.4874>:
      D.4797 = *error;
      if (D.4797 != 0B) goto <D.4876>; else goto <D.4877>;
      <D.4876>:
      monoeg_g_free (text);
      goto fail;
      <D.4877>:
      <D.4875>:
      <D.4873>:
      monoeg_g_free (text);
      goto <D.4694>;
      <D.4693>:
      p = p + 1;
      <D.4694>:
      if (p < end) goto <D.4878>; else goto <D.4695>;
      <D.4878>:
      D.4749 = *p;
      if (D.4749 != 62) goto <D.4693>; else goto <D.4695>;
      <D.4695>:
      D.4836 = context->level;
      D.4879 = D.4836->next;
      context->level = D.4879;
      monoeg_g_slist_free_1 (current);
      context->state = 2;
      goto <D.4680>;
    }
    <D.4880>:
    <D.4680>:
  }
  <D.4666>:
  p = p + 1;
  <D.4697>:
  if (p < end) goto <D.4696>; else goto <D.4698>;
  <D.4698>:
  D.4720 = 1;
  return D.4720;
  fail:
  D.4881 = context->parser.error;
  if (D.4881 != 0B) goto <D.4882>; else goto <D.4883>;
  <D.4882>:
  if (error != 0B) goto <D.4884>; else goto <D.4885>;
  <D.4884>:
  D.4797 = *error;
  if (D.4797 != 0B) goto <D.4886>; else goto <D.4887>;
  <D.4886>:
  D.4881 = context->parser.error;
  D.4816 = context->user_data;
  D.4797 = *error;
  D.4881 (context, D.4797, D.4816);
  <D.4887>:
  <D.4885>:
  <D.4883>:
  destroy_parse_state (context);
  D.4720 = 0;
  return D.4720;
}


my_isalpha (char c)
{
  unsigned char c.8;
  unsigned char D.4892;
  _Bool D.4893;
  unsigned char D.4894;
  _Bool D.4895;
  _Bool D.4896;
  gboolean D.4899;

  c.8 = (unsigned char) c;
  D.4892 = c.8 + 159;
  D.4893 = D.4892 <= 25;
  c.8 = (unsigned char) c;
  D.4894 = c.8 + 191;
  D.4895 = D.4894 <= 25;
  D.4896 = D.4893 | D.4895;
  if (D.4896 != 0) goto <D.4897>; else goto <D.4898>;
  <D.4897>:
  D.4899 = 1;
  return D.4899;
  <D.4898>:
  D.4899 = 0;
  return D.4899;
}


my_isalnum (char c)
{
  unsigned char c.9;
  unsigned char D.4902;
  _Bool D.4903;
  unsigned char D.4904;
  _Bool D.4905;
  _Bool D.4906;
  gboolean D.4909;
  unsigned char D.4910;

  c.9 = (unsigned char) c;
  D.4902 = c.9 + 159;
  D.4903 = D.4902 <= 25;
  c.9 = (unsigned char) c;
  D.4904 = c.9 + 191;
  D.4905 = D.4904 <= 25;
  D.4906 = D.4903 | D.4905;
  if (D.4906 != 0) goto <D.4907>; else goto <D.4908>;
  <D.4907>:
  D.4909 = 1;
  return D.4909;
  <D.4908>:
  c.9 = (unsigned char) c;
  D.4910 = c.9 + 208;
  if (D.4910 <= 9) goto <D.4911>; else goto <D.4912>;
  <D.4911>:
  D.4909 = 1;
  return D.4909;
  <D.4912>:
  D.4909 = 0;
  return D.4909;
}


my_isspace (char c)
{
  _Bool D.4916;
  _Bool D.4917;
  _Bool D.4918;
  _Bool D.4920;
  _Bool D.4921;
  _Bool D.4922;
  gboolean D.4924;

  D.4916 = c == 32;
  D.4917 = c == 9;
  D.4918 = D.4916 | D.4917;
  if (D.4918 != 0) goto <D.4914>; else goto <D.4919>;
  <D.4919>:
  D.4920 = c == 13;
  D.4921 = c == 10;
  D.4922 = D.4920 | D.4921;
  if (D.4922 != 0) goto <D.4914>; else goto <D.4923>;
  <D.4923>:
  if (c == 11) goto <D.4914>; else goto <D.4915>;
  <D.4914>:
  D.4924 = 1;
  return D.4924;
  <D.4915>:
  D.4924 = 0;
  return D.4924;
}


parse_attributes (const char * p, const char * end, char * * * names, char * * * values, struct GError * * error, int * full_stop, int state)
{
  const char * D.4928;
  char D.4929;
  const char * D.4936;
  char D.4939;
  char * name.10;
  struct GError * D.4955;
  int D.4960;
  unsigned int D.4961;
  unsigned int D.4962;
  char * * D.4963;
  void * D.4964;
  char * * D.4965;
  void * D.4966;
  sizetype nnames.11;
  sizetype D.4968;
  sizetype D.4969;
  char * * D.4970;
  char * * D.4971;
  char * value.12;
  unsigned int nnames.13;
  unsigned int D.4974;
  char * * D.4975;
  char * * D.4976;
  int nnames;

  nnames = 0;
  <D.4648>:
  p = skip_space (p, end);
  if (p == end) goto <D.4926>; else goto <D.4927>;
  <D.4926>:
  D.4928 = end;
  return D.4928;
  <D.4927>:
  D.4929 = *p;
  if (D.4929 == 62) goto <D.4930>; else goto <D.4931>;
  <D.4930>:
  *full_stop = 0;
  D.4928 = p;
  return D.4928;
  <D.4931>:
  if (state == 6) goto <D.4932>; else goto <D.4933>;
  <D.4932>:
  D.4929 = *p;
  if (D.4929 == 63) goto <D.4934>; else goto <D.4935>;
  <D.4934>:
  D.4936 = p + 1;
  if (D.4936 < end) goto <D.4937>; else goto <D.4938>;
  <D.4937>:
  D.4936 = p + 1;
  D.4939 = *D.4936;
  if (D.4939 == 62) goto <D.4940>; else goto <D.4941>;
  <D.4940>:
  *full_stop = 0;
  D.4928 = p + 1;
  return D.4928;
  <D.4941>:
  <D.4938>:
  <D.4935>:
  <D.4933>:
  D.4929 = *p;
  if (D.4929 == 47) goto <D.4943>; else goto <D.4942>;
  <D.4943>:
  D.4936 = p + 1;
  if (D.4936 < end) goto <D.4944>; else goto <D.4942>;
  <D.4944>:
  D.4936 = p + 1;
  D.4939 = *D.4936;
  if (D.4939 == 62) goto <D.4945>; else goto <D.4942>;
  <D.4945>:
  *full_stop = 1;
  D.4928 = p + 1;
  return D.4928;
  <D.4942>:
  {
    char * name;
    char * value;

    try
      {
        p = parse_name (p, end, &name);
        if (p == end) goto <D.4946>; else goto <D.4947>;
        <D.4946>:
        D.4928 = p;
        return D.4928;
        <D.4947>:
        p = skip_space (p, end);
        if (p == end) goto <D.4948>; else goto <D.4949>;
        <D.4948>:
        name.10 = name;
        monoeg_g_free (name.10);
        D.4928 = p;
        return D.4928;
        <D.4949>:
        D.4929 = *p;
        if (D.4929 != 61) goto <D.4951>; else goto <D.4952>;
        <D.4951>:
        if (error != 0B) goto <D.4953>; else goto <D.4954>;
        <D.4953>:
        name.10 = name;
        D.4955 = monoeg_g_error_new (1B, 1, "Expected an = after the attribute name `%s\'", name.10);
        *error = D.4955;
        <D.4954>:
        name.10 = name;
        monoeg_g_free (name.10);
        D.4928 = end;
        return D.4928;
        <D.4952>:
        p = p + 1;
        p = skip_space (p, end);
        if (p == end) goto <D.4956>; else goto <D.4957>;
        <D.4956>:
        name.10 = name;
        monoeg_g_free (name.10);
        D.4928 = end;
        return D.4928;
        <D.4957>:
        p = parse_value (p, end, &value, error);
        if (p == end) goto <D.4958>; else goto <D.4959>;
        <D.4958>:
        name.10 = name;
        monoeg_g_free (name.10);
        D.4928 = p;
        return D.4928;
        <D.4959>:
        nnames = nnames + 1;
        D.4960 = nnames + 1;
        D.4961 = (unsigned int) D.4960;
        D.4962 = D.4961 * 4;
        D.4963 = *names;
        D.4964 = monoeg_realloc (D.4963, D.4962);
        *names = D.4964;
        D.4960 = nnames + 1;
        D.4961 = (unsigned int) D.4960;
        D.4962 = D.4961 * 4;
        D.4965 = *values;
        D.4966 = monoeg_realloc (D.4965, D.4962);
        *values = D.4966;
        D.4963 = *names;
        nnames.11 = (sizetype) nnames;
        D.4968 = nnames.11 + 1073741823;
        D.4969 = D.4968 * 4;
        D.4970 = D.4963 + D.4969;
        name.10 = name;
        *D.4970 = name.10;
        D.4965 = *values;
        nnames.11 = (sizetype) nnames;
        D.4968 = nnames.11 + 1073741823;
        D.4969 = D.4968 * 4;
        D.4971 = D.4965 + D.4969;
        value.12 = value;
        *D.4971 = value.12;
        D.4963 = *names;
        nnames.13 = (unsigned int) nnames;
        D.4974 = nnames.13 * 4;
        D.4975 = D.4963 + D.4974;
        *D.4975 = 0B;
        D.4965 = *values;
        nnames.13 = (unsigned int) nnames;
        D.4974 = nnames.13 * 4;
        D.4976 = D.4965 + D.4974;
        *D.4976 = 0B;
      }
    finally
      {
        name = {CLOBBER};
        value = {CLOBBER};
      }
  }
  goto <D.4648>;
}


parse_name (const char * p, const char * end, char * * value)
{
  char D.4981;
  int D.4982;
  int D.4983;
  const char * D.4986;
  int p.14;
  int start.15;
  int D.4989;
  unsigned int D.4990;
  void * D.4991;
  char * D.4992;
  unsigned int l.16;
  sizetype l.17;
  char * D.4997;
  const char * start;
  int l;

  start = p;
  goto <D.4634>;
  <D.4633>:
  p = p + 1;
  <D.4634>:
  if (p < end) goto <D.4980>; else goto <D.4635>;
  <D.4980>:
  D.4981 = *p;
  D.4982 = (int) D.4981;
  D.4983 = my_isalnum (D.4982);
  if (D.4983 != 0) goto <D.4633>; else goto <D.4635>;
  <D.4635>:
  if (p == end) goto <D.4984>; else goto <D.4985>;
  <D.4984>:
  D.4986 = end;
  return D.4986;
  <D.4985>:
  p.14 = (int) p;
  start.15 = (int) start;
  l = p.14 - start.15;
  D.4989 = l + 1;
  D.4990 = (unsigned int) D.4989;
  D.4991 = monoeg_malloc (D.4990);
  *value = D.4991;
  D.4992 = *value;
  if (D.4992 == 0B) goto <D.4993>; else goto <D.4994>;
  <D.4993>:
  D.4986 = end;
  return D.4986;
  <D.4994>:
  l.16 = (unsigned int) l;
  D.4992 = *value;
  strncpy (D.4992, start, l.16);
  D.4992 = *value;
  l.17 = (sizetype) l;
  D.4997 = D.4992 + l.17;
  *D.4997 = 0;
  D.4986 = p;
  return D.4986;
}


skip_space (const char * p, const char * end)
{
  char D.5000;
  int D.5001;
  int D.5002;
  const char * D.5003;

  goto <D.4613>;
  <D.4612>:
  p = p + 1;
  <D.4613>:
  if (p < end) goto <D.4999>; else goto <D.4614>;
  <D.4999>:
  D.5000 = *p;
  D.5001 = (int) D.5000;
  D.5002 = my_isspace (D.5001);
  if (D.5002 != 0) goto <D.4612>; else goto <D.4614>;
  <D.4614>:
  D.5003 = p;
  return D.5003;
}


parse_value (const char * p, const char * end, char * * value, struct GError * * error)
{
  char D.5005;
  struct GError * D.5010;
  const char * D.5011;
  int p.18;
  int start.19;
  int D.5017;
  unsigned int D.5018;
  void * D.5019;
  char * D.5020;
  unsigned int l.20;
  sizetype l.21;
  char * D.5025;
  const char * start;
  int l;

  D.5005 = *p;
  if (D.5005 != 34) goto <D.5006>; else goto <D.5007>;
  <D.5006>:
  if (error != 0B) goto <D.5008>; else goto <D.5009>;
  <D.5008>:
  D.5010 = monoeg_g_error_new (1B, 1, "%s", "Expected the attribute value to start with a quote");
  *error = D.5010;
  <D.5009>:
  D.5011 = end;
  return D.5011;
  <D.5007>:
  p = p + 1;
  start = p;
  goto <D.4624>;
  <D.4623>:
  p = p + 1;
  <D.4624>:
  if (p < end) goto <D.5012>; else goto <D.4625>;
  <D.5012>:
  D.5005 = *p;
  if (D.5005 != 34) goto <D.4623>; else goto <D.4625>;
  <D.4625>:
  if (p == end) goto <D.5013>; else goto <D.5014>;
  <D.5013>:
  D.5011 = end;
  return D.5011;
  <D.5014>:
  p.18 = (int) p;
  start.19 = (int) start;
  l = p.18 - start.19;
  p = p + 1;
  D.5017 = l + 1;
  D.5018 = (unsigned int) D.5017;
  D.5019 = monoeg_malloc (D.5018);
  *value = D.5019;
  D.5020 = *value;
  if (D.5020 == 0B) goto <D.5021>; else goto <D.5022>;
  <D.5021>:
  D.5011 = end;
  return D.5011;
  <D.5022>:
  l.20 = (unsigned int) l;
  D.5020 = *value;
  strncpy (D.5020, start, l.20);
  D.5020 = *value;
  l.21 = (sizetype) l;
  D.5025 = D.5020 + l.21;
  *D.5025 = 0;
  D.5011 = p;
  return D.5011;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.5027;
  unsigned int D.5028;

  D.5028 = __builtin_object_size (__dest, 1);
  D.5027 = __builtin___strncpy_chk (__dest, __src, __len, D.5028);
  return D.5027;
}


destroy_parse_state (struct GMarkupParseContext * context)
{
  void * D.5030;
  struct GSList * D.5031;
  struct GString * D.5032;
  struct GSList * p;

  p = context->level;
  goto <D.4654>;
  <D.4653>:
  D.5030 = p->data;
  monoeg_g_free (D.5030);
  p = p->next;
  <D.4654>:
  if (p != 0B) goto <D.4653>; else goto <D.4655>;
  <D.4655>:
  D.5031 = context->level;
  monoeg_g_slist_free (D.5031);
  D.5032 = context->text;
  if (D.5032 != 0B) goto <D.5033>; else goto <D.5034>;
  <D.5033>:
  D.5032 = context->text;
  monoeg_g_string_free (D.5032, 1);
  <D.5034>:
  context->text = 0B;
  context->level = 0B;
}


monoeg_g_markup_parse_context_end_parse (struct GMarkupParseContext * context, struct GError * * error)
{
  gboolean D.5037;

  if (context == 0B) goto <D.5035>; else goto <D.5036>;
  <D.5035>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 466, "context != NULL");
  D.5037 = 0;
  return D.5037;
  <D.5036>:
  D.5037 = 1;
  return D.5037;
}