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

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


monoeg_g_markup_parse_context_free (struct GMarkupParseContext * context)
{
  void (*<Tb0b>) (void *) D.4728;
  void * D.4731;
  struct GString * D.4732;
  void * D.4735;
  struct GSList * D.4736;
  struct GSList * l;

  if (context == 0B) goto <D.4726>; else goto <D.4727>;
  <D.4726>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 90, "context != NULL");
  return;
  <D.4727>:
  D.4728 = context->user_data_dnotify;
  if (D.4728 != 0B) goto <D.4729>; else goto <D.4730>;
  <D.4729>:
  D.4728 = context->user_data_dnotify;
  D.4731 = context->user_data;
  D.4728 (D.4731);
  <D.4730>:
  D.4732 = context->text;
  if (D.4732 != 0B) goto <D.4733>; else goto <D.4734>;
  <D.4733>:
  D.4732 = context->text;
  monoeg_g_string_free (D.4732, 1);
  <D.4734>:
  l = context->level;
  goto <D.4617>;
  <D.4616>:
  D.4735 = l->data;
  monoeg_g_free (D.4735);
  l = l->next;
  <D.4617>:
  if (l != 0B) goto <D.4616>; else goto <D.4618>;
  <D.4618>:
  D.4736 = context->level;
  monoeg_g_slist_free (D.4736);
  monoeg_g_free (context);
}


monoeg_g_markup_parse_context_parse (struct GMarkupParseContext * context, const gchar * text, gssize text_len, struct GError * * error)
{
  gboolean D.4740;
  sizetype text_len.0;
  <unnamed type> D.4746;
  const char * D.4757;
  char D.4759;
  struct GError * D.4763;
  char D.4765;
  int D.4766;
  int D.4767;
  struct GError * D.4772;
  const char * D.4775;
  char D.4780;
  int D.4783;
  struct GError * D.4788;
  int D.4790;
  struct GError * D.4796;
  int D.4798;
  struct GError * D.4803;
  int D.4804;
  gchar * * names.1;
  gchar * * values.2;
  struct GError * D.4813;
  struct GError * D.4818;
  int element_end.3;
  int element_start.4;
  int D.4821;
  unsigned int D.4822;
  unsigned int l.5;
  sizetype l.6;
  char * D.4826;
  void (*<Td74>) (struct GMarkupParseContext *, const gchar *, const gchar * *, const gchar * *, void *, struct GError * *) D.4829;
  void * D.4832;
  int full_stop.7;
  void (*<Td78>) (struct GMarkupParseContext *, const gchar *, void *, struct GError * *) D.4842;
  struct GSList * D.4852;
  struct GSList * D.4853;
  void (*<Td7c>) (struct GMarkupParseContext *, const gchar *, gsize, void *, struct GError * *) D.4856;
  struct GString * D.4859;
  struct GString * D.4862;
  int D.4863;
  char * D.4875;
  unsigned int D.4876;
  struct GError * D.4887;
  struct GSList * D.4895;
  void (*<Td82>) (struct GMarkupParseContext *, struct GError *, void *) D.4897;
  const char * p;
  const char * end;
  void fail = <<< error >>>;

  if (context == 0B) goto <D.4738>; else goto <D.4739>;
  <D.4738>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 268, "context != NULL");
  D.4740 = 0;
  return D.4740;
  <D.4739>:
  if (text == 0B) goto <D.4741>; else goto <D.4742>;
  <D.4741>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 269, "text != NULL");
  D.4740 = 0;
  return D.4740;
  <D.4742>:
  if (text_len < 0) goto <D.4743>; else goto <D.4744>;
  <D.4743>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 270, "text_len >= 0");
  D.4740 = 0;
  return D.4740;
  <D.4744>:
  text_len.0 = (sizetype) text_len;
  end = text + text_len.0;
  p = text;
  goto <D.4717>;
  <D.4716>:
  {
    char c;

    c = *p;
    D.4746 = context->state;
    switch (D.4746) <default: <D.4896>, case 0: <D.4685>, case 1: <D.4689>, case 2: <D.4707>, case 3: <D.4709>, case 4: <D.4710>, case 5: <D.4708>, case 6: <D.4688>>
    <D.4685>:
    if (c == 32) goto <D.4747>; else goto <D.4749>;
    <D.4749>:
    if (c == 9) goto <D.4747>; else goto <D.4750>;
    <D.4750>:
    if (c == 12) goto <D.4747>; else goto <D.4751>;
    <D.4751>:
    if (c == 10) goto <D.4747>; else goto <D.4752>;
    <D.4752>:
    if (c < 0) goto <D.4747>; else goto <D.4748>;
    <D.4747>:
    // predicted unlikely by continue predictor.
    goto <D.4686>;
    <D.4748>:
    if (c == 60) goto <D.4753>; else goto <D.4754>;
    <D.4753>:
    D.4757 = p + 1;
    if (D.4757 < end) goto <D.4758>; else goto <D.4755>;
    <D.4758>:
    D.4757 = p + 1;
    D.4759 = *D.4757;
    if (D.4759 == 63) goto <D.4760>; else goto <D.4755>;
    <D.4760>:
    context->state = 6;
    p = p + 1;
    goto <D.4756>;
    <D.4755>:
    context->state = 1;
    <D.4756>:
    // predicted unlikely by continue predictor.
    goto <D.4686>;
    <D.4754>:
    if (error != 0B) goto <D.4761>; else goto <D.4762>;
    <D.4761>:
    D.4763 = monoeg_g_error_new (1B, 1, "%s", "Expected < to start the document");
    *error = D.4763;
    <D.4762>:
    goto fail;
    <D.4688>:
    <D.4689>:
    {
      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.4698>;
          <D.4697>:
          p = p + 1;
          <D.4698>:
          if (p < end) goto <D.4764>; else goto <D.4699>;
          <D.4764>:
          D.4765 = *p;
          D.4766 = (int) D.4765;
          D.4767 = my_isspace (D.4766);
          if (D.4767 != 0) goto <D.4697>; else goto <D.4699>;
          <D.4699>:
          if (p == end) 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", "Unfinished element");
          *error = D.4772;
          <D.4771>:
          goto fail;
          <D.4769>:
          D.4765 = *p;
          if (D.4765 == 33) goto <D.4773>; else goto <D.4774>;
          <D.4773>:
          D.4775 = p + 2;
          if (D.4775 < end) goto <D.4776>; else goto <D.4777>;
          <D.4776>:
          D.4757 = p + 1;
          D.4759 = *D.4757;
          if (D.4759 == 45) goto <D.4778>; else goto <D.4779>;
          <D.4778>:
          D.4775 = p + 2;
          D.4780 = *D.4775;
          if (D.4780 == 45) goto <D.4781>; else goto <D.4782>;
          <D.4781>:
          context->state = 5;
          p = p + 2;
          goto <D.4700>;
          <D.4782>:
          <D.4779>:
          <D.4777>:
          <D.4774>:
          D.4765 = *p;
          D.4766 = (int) D.4765;
          D.4783 = my_isalpha (D.4766);
          if (D.4783 == 0) goto <D.4784>; else goto <D.4785>;
          <D.4784>:
          if (error != 0B) goto <D.4786>; else goto <D.4787>;
          <D.4786>:
          D.4788 = monoeg_g_error_new (1B, 1, "%s", "Expected an element name");
          *error = D.4788;
          <D.4787>:
          goto fail;
          <D.4785>:
          p = p + 1;
          goto <D.4702>;
          <D.4701>:
          p = p + 1;
          <D.4702>:
          if (p < end) goto <D.4789>; else goto <D.4703>;
          <D.4789>:
          D.4765 = *p;
          D.4766 = (int) D.4765;
          D.4790 = my_isalnum (D.4766);
          if (D.4790 != 0) goto <D.4701>; else goto <D.4791>;
          <D.4791>:
          D.4765 = *p;
          if (D.4765 == 46) goto <D.4701>; else goto <D.4703>;
          <D.4703>:
          if (p == end) goto <D.4792>; else goto <D.4793>;
          <D.4792>:
          if (error != 0B) goto <D.4794>; else goto <D.4795>;
          <D.4794>:
          D.4796 = monoeg_g_error_new (1B, 1, "%s", "Expected an element");
          *error = D.4796;
          <D.4795>:
          goto fail;
          <D.4793>:
          element_end = p;
          goto <D.4705>;
          <D.4704>:
          p = p + 1;
          <D.4705>:
          if (p < end) goto <D.4797>; else goto <D.4706>;
          <D.4797>:
          D.4765 = *p;
          D.4766 = (int) D.4765;
          D.4798 = my_isspace (D.4766);
          if (D.4798 != 0) goto <D.4704>; else goto <D.4706>;
          <D.4706>:
          if (p == end) goto <D.4799>; else goto <D.4800>;
          <D.4799>:
          if (error != 0B) goto <D.4801>; else goto <D.4802>;
          <D.4801>:
          D.4803 = monoeg_g_error_new (1B, 1, "%s", "Unfinished element");
          *error = D.4803;
          <D.4802>:
          goto fail;
          <D.4800>:
          D.4746 = context->state;
          D.4804 = (int) D.4746;
          p = parse_attributes (p, end, &names, &values, error, &full_stop, D.4804);
          if (p == end) goto <D.4805>; else goto <D.4806>;
          <D.4805>:
          names.1 = names;
          if (names.1 != 0B) goto <D.4808>; else goto <D.4809>;
          <D.4808>:
          names.1 = names;
          monoeg_g_strfreev (names.1);
          values.2 = values;
          monoeg_g_strfreev (values.2);
          <D.4809>:
          if (error != 0B) goto <D.4811>; else goto <D.4812>;
          <D.4811>:
          D.4813 = *error;
          if (D.4813 == 0B) goto <D.4814>; else goto <D.4815>;
          <D.4814>:
          if (error != 0B) goto <D.4816>; else goto <D.4817>;
          <D.4816>:
          D.4818 = monoeg_g_error_new (1B, 1, "%s", "Unfinished sequence");
          *error = D.4818;
          <D.4817>:
          <D.4815>:
          <D.4812>:
          goto fail;
          <D.4806>:
          element_end.3 = (int) element_end;
          element_start.4 = (int) element_start;
          l = element_end.3 - element_start.4;
          D.4821 = l + 1;
          D.4822 = (unsigned int) D.4821;
          ename = monoeg_malloc (D.4822);
          if (ename == 0B) goto fail; else goto <D.4823>;
          <D.4823>:
          l.5 = (unsigned int) l;
          strncpy (ename, element_start, l.5);
          l.6 = (sizetype) l;
          D.4826 = ename + l.6;
          *D.4826 = 0;
          D.4746 = context->state;
          if (D.4746 == 1) goto <D.4827>; else goto <D.4828>;
          <D.4827>:
          D.4829 = context->parser.start_element;
          if (D.4829 != 0B) goto <D.4830>; else goto <D.4831>;
          <D.4830>:
          D.4829 = context->parser.start_element;
          names.1 = names;
          values.2 = values;
          D.4832 = context->user_data;
          D.4829 (context, ename, names.1, values.2, D.4832, error);
          <D.4831>:
          <D.4828>:
          names.1 = names;
          if (names.1 != 0B) goto <D.4833>; else goto <D.4834>;
          <D.4833>:
          names.1 = names;
          monoeg_g_strfreev (names.1);
          values.2 = values;
          monoeg_g_strfreev (values.2);
          <D.4834>:
          if (error != 0B) goto <D.4835>; else goto <D.4836>;
          <D.4835>:
          D.4813 = *error;
          if (D.4813 != 0B) goto <D.4837>; else goto <D.4838>;
          <D.4837>:
          monoeg_g_free (ename);
          goto fail;
          <D.4838>:
          <D.4836>:
          full_stop.7 = full_stop;
          if (full_stop.7 != 0) goto <D.4840>; else goto <D.4841>;
          <D.4840>:
          D.4842 = context->parser.end_element;
          if (D.4842 != 0B) goto <D.4843>; else goto <D.4844>;
          <D.4843>:
          D.4746 = context->state;
          if (D.4746 == 1) goto <D.4845>; else goto <D.4846>;
          <D.4845>:
          D.4842 = context->parser.end_element;
          D.4832 = context->user_data;
          D.4842 (context, ename, D.4832, error);
          if (error != 0B) goto <D.4847>; else goto <D.4848>;
          <D.4847>:
          D.4813 = *error;
          if (D.4813 != 0B) goto <D.4849>; else goto <D.4850>;
          <D.4849>:
          free (ename);
          goto fail;
          <D.4850>:
          <D.4848>:
          <D.4846>:
          <D.4844>:
          monoeg_g_free (ename);
          goto <D.4851>;
          <D.4841>:
          D.4852 = context->level;
          D.4853 = monoeg_g_slist_prepend (D.4852, ename);
          context->level = D.4853;
          <D.4851>:
          context->state = 2;
          goto <D.4700>;
        }
      finally
        {
          full_stop = {CLOBBER};
          names = {CLOBBER};
          values = {CLOBBER};
        }
    }
    <D.4707>:
    if (c == 60) goto <D.4854>; else goto <D.4855>;
    <D.4854>:
    context->state = 3;
    goto <D.4700>;
    <D.4855>:
    D.4856 = context->parser.text;
    if (D.4856 != 0B) goto <D.4857>; else goto <D.4858>;
    <D.4857>:
    D.4859 = context->text;
    if (D.4859 == 0B) goto <D.4860>; else goto <D.4861>;
    <D.4860>:
    D.4862 = monoeg_g_string_new ("");
    context->text = D.4862;
    <D.4861>:
    D.4859 = context->text;
    D.4863 = (int) c;
    monoeg_g_string_append_c (D.4859, D.4863);
    <D.4858>:
    goto <D.4700>;
    <D.4708>:
    D.4765 = *p;
    if (D.4765 != 45) goto <D.4700>; else goto <D.4864>;
    <D.4864>:
    D.4775 = p + 2;
    if (D.4775 < end) goto <D.4865>; else goto <D.4866>;
    <D.4865>:
    D.4757 = p + 1;
    D.4759 = *D.4757;
    if (D.4759 == 45) goto <D.4867>; else goto <D.4868>;
    <D.4867>:
    D.4775 = p + 2;
    D.4780 = *D.4775;
    if (D.4780 == 62) goto <D.4869>; else goto <D.4870>;
    <D.4869>:
    context->state = 2;
    p = p + 2;
    goto <D.4700>;
    <D.4870>:
    <D.4868>:
    <D.4866>:
    goto <D.4700>;
    <D.4709>:
    D.4856 = context->parser.text;
    if (D.4856 != 0B) goto <D.4871>; else goto <D.4872>;
    <D.4871>:
    D.4859 = context->text;
    if (D.4859 != 0B) goto <D.4873>; else goto <D.4874>;
    <D.4873>:
    D.4856 = context->parser.text;
    D.4859 = context->text;
    D.4875 = D.4859->str;
    D.4859 = context->text;
    D.4876 = D.4859->len;
    D.4832 = context->user_data;
    D.4856 (context, D.4875, D.4876, D.4832, error);
    if (error != 0B) goto <D.4877>; else goto <D.4878>;
    <D.4877>:
    D.4813 = *error;
    if (D.4813 != 0B) goto fail; else goto <D.4879>;
    <D.4879>:
    <D.4878>:
    <D.4874>:
    <D.4872>:
    if (c == 47) goto <D.4880>; else goto <D.4881>;
    <D.4880>:
    context->state = 4;
    goto <D.4882>;
    <D.4881>:
    p = p + 4294967295;
    context->state = 1;
    <D.4882>:
    goto <D.4700>;
    <D.4710>:
    {
      struct GSList * current;
      char * text;

      current = context->level;
      D.4852 = context->level;
      if (D.4852 == 0B) goto <D.4883>; else goto <D.4884>;
      <D.4883>:
      if (error != 0B) goto <D.4885>; else goto <D.4886>;
      <D.4885>:
      D.4887 = monoeg_g_error_new (1B, 1, "%s", "Too many closing tags, not enough open tags");
      *error = D.4887;
      <D.4886>:
      goto fail;
      <D.4884>:
      text = current->data;
      D.4842 = context->parser.end_element;
      if (D.4842 != 0B) goto <D.4888>; else goto <D.4889>;
      <D.4888>:
      D.4842 = context->parser.end_element;
      D.4832 = context->user_data;
      D.4842 (context, text, D.4832, error);
      if (error != 0B) goto <D.4890>; else goto <D.4891>;
      <D.4890>:
      D.4813 = *error;
      if (D.4813 != 0B) goto <D.4892>; else goto <D.4893>;
      <D.4892>:
      monoeg_g_free (text);
      goto fail;
      <D.4893>:
      <D.4891>:
      <D.4889>:
      monoeg_g_free (text);
      goto <D.4714>;
      <D.4713>:
      p = p + 1;
      <D.4714>:
      if (p < end) goto <D.4894>; else goto <D.4715>;
      <D.4894>:
      D.4765 = *p;
      if (D.4765 != 62) goto <D.4713>; else goto <D.4715>;
      <D.4715>:
      D.4852 = context->level;
      D.4895 = D.4852->next;
      context->level = D.4895;
      monoeg_g_slist_free_1 (current);
      context->state = 2;
      goto <D.4700>;
    }
    <D.4896>:
    <D.4700>:
  }
  <D.4686>:
  p = p + 1;
  <D.4717>:
  if (p < end) goto <D.4716>; else goto <D.4718>;
  <D.4718>:
  D.4740 = 1;
  return D.4740;
  fail:
  D.4897 = context->parser.error;
  if (D.4897 != 0B) goto <D.4898>; else goto <D.4899>;
  <D.4898>:
  if (error != 0B) goto <D.4900>; else goto <D.4901>;
  <D.4900>:
  D.4813 = *error;
  if (D.4813 != 0B) goto <D.4902>; else goto <D.4903>;
  <D.4902>:
  D.4897 = context->parser.error;
  D.4813 = *error;
  D.4832 = context->user_data;
  D.4897 (context, D.4813, D.4832);
  <D.4903>:
  <D.4901>:
  <D.4899>:
  destroy_parse_state (context);
  D.4740 = 0;
  return D.4740;
}


my_isalpha (char c)
{
  unsigned char c.8;
  unsigned char D.4910;
  unsigned char D.4912;
  gboolean D.4913;

  c.8 = (unsigned char) c;
  D.4910 = c.8 + 159;
  if (D.4910 <= 25) goto <D.4907>; else goto <D.4911>;
  <D.4911>:
  c.8 = (unsigned char) c;
  D.4912 = c.8 + 191;
  if (D.4912 <= 25) goto <D.4907>; else goto <D.4908>;
  <D.4907>:
  D.4913 = 1;
  return D.4913;
  <D.4908>:
  D.4913 = 0;
  return D.4913;
}


my_isalnum (char c)
{
  unsigned char c.9;
  unsigned char D.4918;
  unsigned char D.4920;
  gboolean D.4921;
  unsigned char D.4922;

  c.9 = (unsigned char) c;
  D.4918 = c.9 + 159;
  if (D.4918 <= 25) goto <D.4915>; else goto <D.4919>;
  <D.4919>:
  c.9 = (unsigned char) c;
  D.4920 = c.9 + 191;
  if (D.4920 <= 25) goto <D.4915>; else goto <D.4916>;
  <D.4915>:
  D.4921 = 1;
  return D.4921;
  <D.4916>:
  c.9 = (unsigned char) c;
  D.4922 = c.9 + 208;
  if (D.4922 <= 9) goto <D.4923>; else goto <D.4924>;
  <D.4923>:
  D.4921 = 1;
  return D.4921;
  <D.4924>:
  D.4921 = 0;
  return D.4921;
}


my_isspace (char c)
{
  gboolean D.4932;

  if (c == 32) goto <D.4926>; else goto <D.4928>;
  <D.4928>:
  if (c == 9) goto <D.4926>; else goto <D.4929>;
  <D.4929>:
  if (c == 13) goto <D.4926>; else goto <D.4930>;
  <D.4930>:
  if (c == 10) goto <D.4926>; else goto <D.4931>;
  <D.4931>:
  if (c == 11) goto <D.4926>; else goto <D.4927>;
  <D.4926>:
  D.4932 = 1;
  return D.4932;
  <D.4927>:
  D.4932 = 0;
  return D.4932;
}


parse_attributes (const char * p, const char * end, char * * * names, char * * * values, struct GError * * error, int * full_stop, int state)
{
  const char * D.4936;
  char D.4937;
  const char * D.4944;
  char D.4947;
  char * name.10;
  struct GError * D.4963;
  char * * D.4968;
  int D.4969;
  unsigned int D.4970;
  unsigned int D.4971;
  void * D.4972;
  char * * D.4973;
  void * D.4974;
  sizetype nnames.11;
  sizetype D.4976;
  sizetype D.4977;
  char * * D.4978;
  char * * D.4979;
  char * value.12;
  unsigned int nnames.13;
  unsigned int D.4982;
  char * * D.4983;
  char * * D.4984;
  int nnames;

  nnames = 0;
  <D.4668>:
  p = skip_space (p, end);
  if (p == end) goto <D.4934>; else goto <D.4935>;
  <D.4934>:
  D.4936 = end;
  return D.4936;
  <D.4935>:
  D.4937 = *p;
  if (D.4937 == 62) goto <D.4938>; else goto <D.4939>;
  <D.4938>:
  *full_stop = 0;
  D.4936 = p;
  return D.4936;
  <D.4939>:
  if (state == 6) goto <D.4940>; else goto <D.4941>;
  <D.4940>:
  D.4937 = *p;
  if (D.4937 == 63) goto <D.4942>; else goto <D.4943>;
  <D.4942>:
  D.4944 = p + 1;
  if (D.4944 < end) goto <D.4945>; else goto <D.4946>;
  <D.4945>:
  D.4944 = p + 1;
  D.4947 = *D.4944;
  if (D.4947 == 62) goto <D.4948>; else goto <D.4949>;
  <D.4948>:
  *full_stop = 0;
  D.4936 = p + 1;
  return D.4936;
  <D.4949>:
  <D.4946>:
  <D.4943>:
  <D.4941>:
  D.4937 = *p;
  if (D.4937 == 47) goto <D.4951>; else goto <D.4950>;
  <D.4951>:
  D.4944 = p + 1;
  if (D.4944 < end) goto <D.4952>; else goto <D.4950>;
  <D.4952>:
  D.4944 = p + 1;
  D.4947 = *D.4944;
  if (D.4947 == 62) goto <D.4953>; else goto <D.4950>;
  <D.4953>:
  *full_stop = 1;
  D.4936 = p + 1;
  return D.4936;
  <D.4950>:
  {
    char * name;
    char * value;

    try
      {
        p = parse_name (p, end, &name);
        if (p == end) goto <D.4954>; else goto <D.4955>;
        <D.4954>:
        D.4936 = p;
        return D.4936;
        <D.4955>:
        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.4936 = p;
        return D.4936;
        <D.4957>:
        D.4937 = *p;
        if (D.4937 != 61) goto <D.4959>; else goto <D.4960>;
        <D.4959>:
        if (error != 0B) goto <D.4961>; else goto <D.4962>;
        <D.4961>:
        name.10 = name;
        D.4963 = monoeg_g_error_new (1B, 1, "Expected an = after the attribute name `%s\'", name.10);
        *error = D.4963;
        <D.4962>:
        name.10 = name;
        monoeg_g_free (name.10);
        D.4936 = end;
        return D.4936;
        <D.4960>:
        p = p + 1;
        p = skip_space (p, end);
        if (p == end) goto <D.4964>; else goto <D.4965>;
        <D.4964>:
        name.10 = name;
        monoeg_g_free (name.10);
        D.4936 = end;
        return D.4936;
        <D.4965>:
        p = parse_value (p, end, &value, error);
        if (p == end) goto <D.4966>; else goto <D.4967>;
        <D.4966>:
        name.10 = name;
        monoeg_g_free (name.10);
        D.4936 = p;
        return D.4936;
        <D.4967>:
        nnames = nnames + 1;
        D.4968 = *names;
        D.4969 = nnames + 1;
        D.4970 = (unsigned int) D.4969;
        D.4971 = D.4970 * 4;
        D.4972 = monoeg_realloc (D.4968, D.4971);
        *names = D.4972;
        D.4973 = *values;
        D.4969 = nnames + 1;
        D.4970 = (unsigned int) D.4969;
        D.4971 = D.4970 * 4;
        D.4974 = monoeg_realloc (D.4973, D.4971);
        *values = D.4974;
        D.4968 = *names;
        nnames.11 = (sizetype) nnames;
        D.4976 = nnames.11 + 1073741823;
        D.4977 = D.4976 * 4;
        D.4978 = D.4968 + D.4977;
        name.10 = name;
        *D.4978 = name.10;
        D.4973 = *values;
        nnames.11 = (sizetype) nnames;
        D.4976 = nnames.11 + 1073741823;
        D.4977 = D.4976 * 4;
        D.4979 = D.4973 + D.4977;
        value.12 = value;
        *D.4979 = value.12;
        D.4968 = *names;
        nnames.13 = (unsigned int) nnames;
        D.4982 = nnames.13 * 4;
        D.4983 = D.4968 + D.4982;
        *D.4983 = 0B;
        D.4973 = *values;
        nnames.13 = (unsigned int) nnames;
        D.4982 = nnames.13 * 4;
        D.4984 = D.4973 + D.4982;
        *D.4984 = 0B;
      }
    finally
      {
        name = {CLOBBER};
        value = {CLOBBER};
      }
  }
  goto <D.4668>;
}


parse_name (const char * p, const char * end, char * * value)
{
  char D.4989;
  int D.4990;
  int D.4991;
  const char * D.4994;
  int p.14;
  int start.15;
  int D.4997;
  unsigned int D.4998;
  void * D.4999;
  char * D.5000;
  unsigned int l.16;
  sizetype l.17;
  char * D.5005;
  const char * start;
  int l;

  start = p;
  goto <D.4654>;
  <D.4653>:
  p = p + 1;
  <D.4654>:
  if (p < end) goto <D.4988>; else goto <D.4655>;
  <D.4988>:
  D.4989 = *p;
  D.4990 = (int) D.4989;
  D.4991 = my_isalnum (D.4990);
  if (D.4991 != 0) goto <D.4653>; else goto <D.4655>;
  <D.4655>:
  if (p == end) goto <D.4992>; else goto <D.4993>;
  <D.4992>:
  D.4994 = end;
  return D.4994;
  <D.4993>:
  p.14 = (int) p;
  start.15 = (int) start;
  l = p.14 - start.15;
  D.4997 = l + 1;
  D.4998 = (unsigned int) D.4997;
  D.4999 = monoeg_malloc (D.4998);
  *value = D.4999;
  D.5000 = *value;
  if (D.5000 == 0B) goto <D.5001>; else goto <D.5002>;
  <D.5001>:
  D.4994 = end;
  return D.4994;
  <D.5002>:
  D.5000 = *value;
  l.16 = (unsigned int) l;
  strncpy (D.5000, start, l.16);
  D.5000 = *value;
  l.17 = (sizetype) l;
  D.5005 = D.5000 + l.17;
  *D.5005 = 0;
  D.4994 = p;
  return D.4994;
}


skip_space (const char * p, const char * end)
{
  char D.5008;
  int D.5009;
  int D.5010;
  const char * D.5011;

  goto <D.4633>;
  <D.4632>:
  p = p + 1;
  <D.4633>:
  if (p < end) goto <D.5007>; else goto <D.4634>;
  <D.5007>:
  D.5008 = *p;
  D.5009 = (int) D.5008;
  D.5010 = my_isspace (D.5009);
  if (D.5010 != 0) goto <D.4632>; else goto <D.4634>;
  <D.4634>:
  D.5011 = p;
  return D.5011;
}


parse_value (const char * p, const char * end, char * * value, struct GError * * error)
{
  char D.5013;
  struct GError * D.5018;
  const char * D.5019;
  int p.18;
  int start.19;
  int D.5025;
  unsigned int D.5026;
  void * D.5027;
  char * D.5028;
  unsigned int l.20;
  sizetype l.21;
  char * D.5033;
  const char * start;
  int l;

  D.5013 = *p;
  if (D.5013 != 34) goto <D.5014>; else goto <D.5015>;
  <D.5014>:
  if (error != 0B) goto <D.5016>; else goto <D.5017>;
  <D.5016>:
  D.5018 = monoeg_g_error_new (1B, 1, "%s", "Expected the attribute value to start with a quote");
  *error = D.5018;
  <D.5017>:
  D.5019 = end;
  return D.5019;
  <D.5015>:
  p = p + 1;
  start = p;
  goto <D.4644>;
  <D.4643>:
  p = p + 1;
  <D.4644>:
  if (p < end) goto <D.5020>; else goto <D.4645>;
  <D.5020>:
  D.5013 = *p;
  if (D.5013 != 34) goto <D.4643>; else goto <D.4645>;
  <D.4645>:
  if (p == end) goto <D.5021>; else goto <D.5022>;
  <D.5021>:
  D.5019 = end;
  return D.5019;
  <D.5022>:
  p.18 = (int) p;
  start.19 = (int) start;
  l = p.18 - start.19;
  p = p + 1;
  D.5025 = l + 1;
  D.5026 = (unsigned int) D.5025;
  D.5027 = monoeg_malloc (D.5026);
  *value = D.5027;
  D.5028 = *value;
  if (D.5028 == 0B) goto <D.5029>; else goto <D.5030>;
  <D.5029>:
  D.5019 = end;
  return D.5019;
  <D.5030>:
  D.5028 = *value;
  l.20 = (unsigned int) l;
  strncpy (D.5028, start, l.20);
  D.5028 = *value;
  l.21 = (sizetype) l;
  D.5033 = D.5028 + l.21;
  *D.5033 = 0;
  D.5019 = p;
  return D.5019;
}


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

  D.5036 = __builtin_object_size (__dest, 1);
  D.5035 = __builtin___strncpy_chk (__dest, __src, __len, D.5036);
  return D.5035;
}


destroy_parse_state (struct GMarkupParseContext * context)
{
  void * D.5038;
  struct GSList * D.5039;
  struct GString * D.5040;
  struct GSList * p;

  p = context->level;
  goto <D.4674>;
  <D.4673>:
  D.5038 = p->data;
  monoeg_g_free (D.5038);
  p = p->next;
  <D.4674>:
  if (p != 0B) goto <D.4673>; else goto <D.4675>;
  <D.4675>:
  D.5039 = context->level;
  monoeg_g_slist_free (D.5039);
  D.5040 = context->text;
  if (D.5040 != 0B) goto <D.5041>; else goto <D.5042>;
  <D.5041>:
  D.5040 = context->text;
  monoeg_g_string_free (D.5040, 1);
  <D.5042>:
  context->text = 0B;
  context->level = 0B;
}


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

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