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

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


monoeg_g_markup_parse_context_free (struct GMarkupParseContext * context)
{
  void (*<T159b>) (void *) D.7317;
  void * D.7320;
  struct GString * D.7321;
  void * D.7324;
  struct GSList * D.7325;
  struct GSList * l;

  if (context == 0B) goto <D.7315>; else goto <D.7316>;
  <D.7315>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 90, "context != NULL");
  return;
  <D.7316>:
  D.7317 = context->user_data_dnotify;
  if (D.7317 != 0B) goto <D.7318>; else goto <D.7319>;
  <D.7318>:
  D.7317 = context->user_data_dnotify;
  D.7320 = context->user_data;
  D.7317 (D.7320);
  <D.7319>:
  D.7321 = context->text;
  if (D.7321 != 0B) goto <D.7322>; else goto <D.7323>;
  <D.7322>:
  D.7321 = context->text;
  monoeg_g_string_free (D.7321, 1);
  <D.7323>:
  l = context->level;
  goto <D.7204>;
  <D.7203>:
  D.7324 = l->data;
  monoeg_g_free (D.7324);
  l = l->next;
  <D.7204>:
  if (l != 0B) goto <D.7203>; else goto <D.7205>;
  <D.7205>:
  D.7325 = context->level;
  monoeg_g_slist_free (D.7325);
  monoeg_g_free (context);
}


monoeg_g_markup_parse_context_parse (struct GMarkupParseContext * context, const gchar * text, gssize text_len, struct GError * * error)
{
  gboolean D.7329;
  sizetype text_len.0;
  <unnamed type> D.7335;
  _Bool D.7338;
  _Bool D.7339;
  _Bool D.7340;
  _Bool D.7342;
  _Bool D.7343;
  _Bool D.7344;
  signed char c.1;
  const char * D.7351;
  char D.7353;
  struct GError * D.7357;
  char D.7359;
  int D.7360;
  struct GError * D.7365;
  const char * D.7368;
  char D.7373;
  int D.7376;
  struct GError * D.7381;
  int D.7383;
  struct GError * D.7389;
  int D.7391;
  struct GError * D.7396;
  int D.7397;
  gchar * * names.2;
  gchar * * values.3;
  struct GError * D.7406;
  struct GError * D.7411;
  int element_end.4;
  int element_start.5;
  int D.7414;
  unsigned int D.7415;
  unsigned int l.6;
  sizetype l.7;
  char * D.7419;
  void (*<T1802>) (struct GMarkupParseContext *, const gchar *, const gchar * *, const gchar * *, void *, struct GError * *) D.7422;
  void * D.7425;
  int full_stop.8;
  void (*<T1806>) (struct GMarkupParseContext *, const gchar *, void *, struct GError * *) D.7435;
  struct GSList * D.7445;
  struct GSList * D.7446;
  void (*<T180a>) (struct GMarkupParseContext *, const gchar *, gsize, void *, struct GError * *) D.7449;
  struct GString * D.7452;
  struct GString * D.7455;
  char * D.7467;
  unsigned int D.7468;
  struct GError * D.7479;
  struct GSList * D.7487;
  void (*<T1810>) (struct GMarkupParseContext *, struct GError *, void *) D.7489;
  const char * p;
  const char * end;
  void fail = <<< error >>>;

  if (context == 0B) goto <D.7327>; else goto <D.7328>;
  <D.7327>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 268, "context != NULL");
  D.7329 = 0;
  return D.7329;
  <D.7328>:
  if (text == 0B) goto <D.7330>; else goto <D.7331>;
  <D.7330>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 269, "text != NULL");
  D.7329 = 0;
  return D.7329;
  <D.7331>:
  if (text_len < 0) goto <D.7332>; else goto <D.7333>;
  <D.7332>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 270, "text_len >= 0");
  D.7329 = 0;
  return D.7329;
  <D.7333>:
  text_len.0 = (sizetype) text_len;
  end = text + text_len.0;
  p = text;
  goto <D.7304>;
  <D.7303>:
  {
    char c;

    c = *p;
    D.7335 = context->state;
    switch (D.7335) <default: <D.7488>, case 0: <D.7272>, case 1: <D.7276>, case 2: <D.7294>, case 3: <D.7296>, case 4: <D.7297>, case 5: <D.7295>, case 6: <D.7275>>
    <D.7272>:
    D.7338 = c == 32;
    D.7339 = c == 9;
    D.7340 = D.7338 | D.7339;
    if (D.7340 != 0) goto <D.7336>; else goto <D.7341>;
    <D.7341>:
    D.7342 = c == 12;
    D.7343 = c == 10;
    D.7344 = D.7342 | D.7343;
    if (D.7344 != 0) goto <D.7336>; else goto <D.7345>;
    <D.7345>:
    c.1 = (signed char) c;
    if (c.1 < 0) goto <D.7336>; else goto <D.7337>;
    <D.7336>:
    // predicted unlikely by continue predictor.
    goto <D.7273>;
    <D.7337>:
    if (c == 60) goto <D.7347>; else goto <D.7348>;
    <D.7347>:
    D.7351 = p + 1;
    if (D.7351 < end) goto <D.7352>; else goto <D.7349>;
    <D.7352>:
    D.7351 = p + 1;
    D.7353 = *D.7351;
    if (D.7353 == 63) goto <D.7354>; else goto <D.7349>;
    <D.7354>:
    context->state = 6;
    p = p + 1;
    goto <D.7350>;
    <D.7349>:
    context->state = 1;
    <D.7350>:
    // predicted unlikely by continue predictor.
    goto <D.7273>;
    <D.7348>:
    if (error != 0B) goto <D.7355>; else goto <D.7356>;
    <D.7355>:
    D.7357 = monoeg_g_error_new (1B, 1, "%s", "Expected < to start the document");
    *error = D.7357;
    <D.7356>:
    goto fail;
    <D.7275>:
    <D.7276>:
    {
      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.7285>;
          <D.7284>:
          p = p + 1;
          <D.7285>:
          if (p < end) goto <D.7358>; else goto <D.7286>;
          <D.7358>:
          D.7359 = *p;
          D.7360 = my_isspace (D.7359);
          if (D.7360 != 0) goto <D.7284>; else goto <D.7286>;
          <D.7286>:
          if (p == end) goto <D.7361>; else goto <D.7362>;
          <D.7361>:
          if (error != 0B) goto <D.7363>; else goto <D.7364>;
          <D.7363>:
          D.7365 = monoeg_g_error_new (1B, 1, "%s", "Unfinished element");
          *error = D.7365;
          <D.7364>:
          goto fail;
          <D.7362>:
          D.7359 = *p;
          if (D.7359 == 33) goto <D.7366>; else goto <D.7367>;
          <D.7366>:
          D.7368 = p + 2;
          if (D.7368 < end) goto <D.7369>; else goto <D.7370>;
          <D.7369>:
          D.7351 = p + 1;
          D.7353 = *D.7351;
          if (D.7353 == 45) goto <D.7371>; else goto <D.7372>;
          <D.7371>:
          D.7368 = p + 2;
          D.7373 = *D.7368;
          if (D.7373 == 45) goto <D.7374>; else goto <D.7375>;
          <D.7374>:
          context->state = 5;
          p = p + 2;
          goto <D.7287>;
          <D.7375>:
          <D.7372>:
          <D.7370>:
          <D.7367>:
          D.7359 = *p;
          D.7376 = my_isalpha (D.7359);
          if (D.7376 == 0) goto <D.7377>; else goto <D.7378>;
          <D.7377>:
          if (error != 0B) goto <D.7379>; else goto <D.7380>;
          <D.7379>:
          D.7381 = monoeg_g_error_new (1B, 1, "%s", "Expected an element name");
          *error = D.7381;
          <D.7380>:
          goto fail;
          <D.7378>:
          p = p + 1;
          goto <D.7289>;
          <D.7288>:
          p = p + 1;
          <D.7289>:
          if (p < end) goto <D.7382>; else goto <D.7290>;
          <D.7382>:
          D.7359 = *p;
          D.7383 = my_isalnum (D.7359);
          if (D.7383 != 0) goto <D.7288>; else goto <D.7384>;
          <D.7384>:
          D.7359 = *p;
          if (D.7359 == 46) goto <D.7288>; else goto <D.7290>;
          <D.7290>:
          if (p == end) goto <D.7385>; else goto <D.7386>;
          <D.7385>:
          if (error != 0B) goto <D.7387>; else goto <D.7388>;
          <D.7387>:
          D.7389 = monoeg_g_error_new (1B, 1, "%s", "Expected an element");
          *error = D.7389;
          <D.7388>:
          goto fail;
          <D.7386>:
          element_end = p;
          goto <D.7292>;
          <D.7291>:
          p = p + 1;
          <D.7292>:
          if (p < end) goto <D.7390>; else goto <D.7293>;
          <D.7390>:
          D.7359 = *p;
          D.7391 = my_isspace (D.7359);
          if (D.7391 != 0) goto <D.7291>; else goto <D.7293>;
          <D.7293>:
          if (p == end) goto <D.7392>; else goto <D.7393>;
          <D.7392>:
          if (error != 0B) goto <D.7394>; else goto <D.7395>;
          <D.7394>:
          D.7396 = monoeg_g_error_new (1B, 1, "%s", "Unfinished element");
          *error = D.7396;
          <D.7395>:
          goto fail;
          <D.7393>:
          D.7335 = context->state;
          D.7397 = (int) D.7335;
          p = parse_attributes (p, end, &names, &values, error, &full_stop, D.7397);
          if (p == end) goto <D.7398>; else goto <D.7399>;
          <D.7398>:
          names.2 = names;
          if (names.2 != 0B) goto <D.7401>; else goto <D.7402>;
          <D.7401>:
          names.2 = names;
          monoeg_g_strfreev (names.2);
          values.3 = values;
          monoeg_g_strfreev (values.3);
          <D.7402>:
          if (error != 0B) goto <D.7404>; else goto <D.7405>;
          <D.7404>:
          D.7406 = *error;
          if (D.7406 == 0B) goto <D.7407>; else goto <D.7408>;
          <D.7407>:
          if (error != 0B) goto <D.7409>; else goto <D.7410>;
          <D.7409>:
          D.7411 = monoeg_g_error_new (1B, 1, "%s", "Unfinished sequence");
          *error = D.7411;
          <D.7410>:
          <D.7408>:
          <D.7405>:
          goto fail;
          <D.7399>:
          element_end.4 = (int) element_end;
          element_start.5 = (int) element_start;
          l = element_end.4 - element_start.5;
          D.7414 = l + 1;
          D.7415 = (unsigned int) D.7414;
          ename = monoeg_malloc (D.7415);
          if (ename == 0B) goto fail; else goto <D.7416>;
          <D.7416>:
          l.6 = (unsigned int) l;
          strncpy (ename, element_start, l.6);
          l.7 = (sizetype) l;
          D.7419 = ename + l.7;
          *D.7419 = 0;
          D.7335 = context->state;
          if (D.7335 == 1) goto <D.7420>; else goto <D.7421>;
          <D.7420>:
          D.7422 = context->parser.start_element;
          if (D.7422 != 0B) goto <D.7423>; else goto <D.7424>;
          <D.7423>:
          D.7422 = context->parser.start_element;
          names.2 = names;
          values.3 = values;
          D.7425 = context->user_data;
          D.7422 (context, ename, names.2, values.3, D.7425, error);
          <D.7424>:
          <D.7421>:
          names.2 = names;
          if (names.2 != 0B) goto <D.7426>; else goto <D.7427>;
          <D.7426>:
          names.2 = names;
          monoeg_g_strfreev (names.2);
          values.3 = values;
          monoeg_g_strfreev (values.3);
          <D.7427>:
          if (error != 0B) goto <D.7428>; else goto <D.7429>;
          <D.7428>:
          D.7406 = *error;
          if (D.7406 != 0B) goto <D.7430>; else goto <D.7431>;
          <D.7430>:
          monoeg_g_free (ename);
          goto fail;
          <D.7431>:
          <D.7429>:
          full_stop.8 = full_stop;
          if (full_stop.8 != 0) goto <D.7433>; else goto <D.7434>;
          <D.7433>:
          D.7435 = context->parser.end_element;
          if (D.7435 != 0B) goto <D.7436>; else goto <D.7437>;
          <D.7436>:
          D.7335 = context->state;
          if (D.7335 == 1) goto <D.7438>; else goto <D.7439>;
          <D.7438>:
          D.7435 = context->parser.end_element;
          D.7425 = context->user_data;
          D.7435 (context, ename, D.7425, error);
          if (error != 0B) goto <D.7440>; else goto <D.7441>;
          <D.7440>:
          D.7406 = *error;
          if (D.7406 != 0B) goto <D.7442>; else goto <D.7443>;
          <D.7442>:
          free (ename);
          goto fail;
          <D.7443>:
          <D.7441>:
          <D.7439>:
          <D.7437>:
          monoeg_g_free (ename);
          goto <D.7444>;
          <D.7434>:
          D.7445 = context->level;
          D.7446 = monoeg_g_slist_prepend (D.7445, ename);
          context->level = D.7446;
          <D.7444>:
          context->state = 2;
          goto <D.7287>;
        }
      finally
        {
          full_stop = {CLOBBER};
          names = {CLOBBER};
          values = {CLOBBER};
        }
    }
    <D.7294>:
    if (c == 60) goto <D.7447>; else goto <D.7448>;
    <D.7447>:
    context->state = 3;
    goto <D.7287>;
    <D.7448>:
    D.7449 = context->parser.text;
    if (D.7449 != 0B) goto <D.7450>; else goto <D.7451>;
    <D.7450>:
    D.7452 = context->text;
    if (D.7452 == 0B) goto <D.7453>; else goto <D.7454>;
    <D.7453>:
    D.7455 = monoeg_g_string_new ("");
    context->text = D.7455;
    <D.7454>:
    D.7452 = context->text;
    monoeg_g_string_append_c (D.7452, c);
    <D.7451>:
    goto <D.7287>;
    <D.7295>:
    D.7359 = *p;
    if (D.7359 != 45) goto <D.7287>; else goto <D.7456>;
    <D.7456>:
    D.7368 = p + 2;
    if (D.7368 < end) goto <D.7457>; else goto <D.7458>;
    <D.7457>:
    D.7351 = p + 1;
    D.7353 = *D.7351;
    if (D.7353 == 45) goto <D.7459>; else goto <D.7460>;
    <D.7459>:
    D.7368 = p + 2;
    D.7373 = *D.7368;
    if (D.7373 == 62) goto <D.7461>; else goto <D.7462>;
    <D.7461>:
    context->state = 2;
    p = p + 2;
    goto <D.7287>;
    <D.7462>:
    <D.7460>:
    <D.7458>:
    goto <D.7287>;
    <D.7296>:
    D.7449 = context->parser.text;
    if (D.7449 != 0B) goto <D.7463>; else goto <D.7464>;
    <D.7463>:
    D.7452 = context->text;
    if (D.7452 != 0B) goto <D.7465>; else goto <D.7466>;
    <D.7465>:
    D.7449 = context->parser.text;
    D.7452 = context->text;
    D.7467 = D.7452->str;
    D.7452 = context->text;
    D.7468 = D.7452->len;
    D.7425 = context->user_data;
    D.7449 (context, D.7467, D.7468, D.7425, error);
    if (error != 0B) goto <D.7469>; else goto <D.7470>;
    <D.7469>:
    D.7406 = *error;
    if (D.7406 != 0B) goto fail; else goto <D.7471>;
    <D.7471>:
    <D.7470>:
    <D.7466>:
    <D.7464>:
    if (c == 47) goto <D.7472>; else goto <D.7473>;
    <D.7472>:
    context->state = 4;
    goto <D.7474>;
    <D.7473>:
    p = p + 4294967295;
    context->state = 1;
    <D.7474>:
    goto <D.7287>;
    <D.7297>:
    {
      struct GSList * current;
      char * text;

      current = context->level;
      D.7445 = context->level;
      if (D.7445 == 0B) goto <D.7475>; else goto <D.7476>;
      <D.7475>:
      if (error != 0B) goto <D.7477>; else goto <D.7478>;
      <D.7477>:
      D.7479 = monoeg_g_error_new (1B, 1, "%s", "Too many closing tags, not enough open tags");
      *error = D.7479;
      <D.7478>:
      goto fail;
      <D.7476>:
      text = current->data;
      D.7435 = context->parser.end_element;
      if (D.7435 != 0B) goto <D.7480>; else goto <D.7481>;
      <D.7480>:
      D.7435 = context->parser.end_element;
      D.7425 = context->user_data;
      D.7435 (context, text, D.7425, error);
      if (error != 0B) goto <D.7482>; else goto <D.7483>;
      <D.7482>:
      D.7406 = *error;
      if (D.7406 != 0B) goto <D.7484>; else goto <D.7485>;
      <D.7484>:
      monoeg_g_free (text);
      goto fail;
      <D.7485>:
      <D.7483>:
      <D.7481>:
      monoeg_g_free (text);
      goto <D.7301>;
      <D.7300>:
      p = p + 1;
      <D.7301>:
      if (p < end) goto <D.7486>; else goto <D.7302>;
      <D.7486>:
      D.7359 = *p;
      if (D.7359 != 62) goto <D.7300>; else goto <D.7302>;
      <D.7302>:
      D.7445 = context->level;
      D.7487 = D.7445->next;
      context->level = D.7487;
      monoeg_g_slist_free_1 (current);
      context->state = 2;
      goto <D.7287>;
    }
    <D.7488>:
    <D.7287>:
  }
  <D.7273>:
  p = p + 1;
  <D.7304>:
  if (p < end) goto <D.7303>; else goto <D.7305>;
  <D.7305>:
  D.7329 = 1;
  return D.7329;
  fail:
  D.7489 = context->parser.error;
  if (D.7489 != 0B) goto <D.7490>; else goto <D.7491>;
  <D.7490>:
  if (error != 0B) goto <D.7492>; else goto <D.7493>;
  <D.7492>:
  D.7406 = *error;
  if (D.7406 != 0B) goto <D.7494>; else goto <D.7495>;
  <D.7494>:
  D.7489 = context->parser.error;
  D.7406 = *error;
  D.7425 = context->user_data;
  D.7489 (context, D.7406, D.7425);
  <D.7495>:
  <D.7493>:
  <D.7491>:
  destroy_parse_state (context);
  D.7329 = 0;
  return D.7329;
}


my_isalpha (char c)
{
  char D.7499;
  _Bool D.7500;
  char D.7501;
  _Bool D.7502;
  _Bool D.7503;
  gboolean D.7506;

  D.7499 = c + 159;
  D.7500 = D.7499 <= 25;
  D.7501 = c + 191;
  D.7502 = D.7501 <= 25;
  D.7503 = D.7500 | D.7502;
  if (D.7503 != 0) goto <D.7504>; else goto <D.7505>;
  <D.7504>:
  D.7506 = 1;
  return D.7506;
  <D.7505>:
  D.7506 = 0;
  return D.7506;
}


my_isalnum (char c)
{
  char D.7508;
  _Bool D.7509;
  char D.7510;
  _Bool D.7511;
  _Bool D.7512;
  gboolean D.7515;
  char D.7516;

  D.7508 = c + 159;
  D.7509 = D.7508 <= 25;
  D.7510 = c + 191;
  D.7511 = D.7510 <= 25;
  D.7512 = D.7509 | D.7511;
  if (D.7512 != 0) goto <D.7513>; else goto <D.7514>;
  <D.7513>:
  D.7515 = 1;
  return D.7515;
  <D.7514>:
  D.7516 = c + 208;
  if (D.7516 <= 9) goto <D.7517>; else goto <D.7518>;
  <D.7517>:
  D.7515 = 1;
  return D.7515;
  <D.7518>:
  D.7515 = 0;
  return D.7515;
}


my_isspace (char c)
{
  _Bool D.7522;
  _Bool D.7523;
  _Bool D.7524;
  _Bool D.7526;
  _Bool D.7527;
  _Bool D.7528;
  gboolean D.7530;

  D.7522 = c == 32;
  D.7523 = c == 9;
  D.7524 = D.7522 | D.7523;
  if (D.7524 != 0) goto <D.7520>; else goto <D.7525>;
  <D.7525>:
  D.7526 = c == 13;
  D.7527 = c == 10;
  D.7528 = D.7526 | D.7527;
  if (D.7528 != 0) goto <D.7520>; else goto <D.7529>;
  <D.7529>:
  if (c == 11) goto <D.7520>; else goto <D.7521>;
  <D.7520>:
  D.7530 = 1;
  return D.7530;
  <D.7521>:
  D.7530 = 0;
  return D.7530;
}


parse_attributes (const char * p, const char * end, char * * * names, char * * * values, struct GError * * error, int * full_stop, int state)
{
  const char * D.7534;
  char D.7535;
  const char * D.7542;
  char D.7545;
  char * name.9;
  struct GError * D.7561;
  char * * D.7566;
  int D.7567;
  unsigned int D.7568;
  unsigned int D.7569;
  void * D.7570;
  char * * D.7571;
  void * D.7572;
  sizetype nnames.10;
  sizetype D.7574;
  sizetype D.7575;
  char * * D.7576;
  char * * D.7577;
  char * value.11;
  unsigned int nnames.12;
  unsigned int D.7580;
  char * * D.7581;
  char * * D.7582;
  int nnames;

  nnames = 0;
  <D.7255>:
  p = skip_space (p, end);
  if (p == end) goto <D.7532>; else goto <D.7533>;
  <D.7532>:
  D.7534 = end;
  return D.7534;
  <D.7533>:
  D.7535 = *p;
  if (D.7535 == 62) goto <D.7536>; else goto <D.7537>;
  <D.7536>:
  *full_stop = 0;
  D.7534 = p;
  return D.7534;
  <D.7537>:
  if (state == 6) goto <D.7538>; else goto <D.7539>;
  <D.7538>:
  D.7535 = *p;
  if (D.7535 == 63) goto <D.7540>; else goto <D.7541>;
  <D.7540>:
  D.7542 = p + 1;
  if (D.7542 < end) goto <D.7543>; else goto <D.7544>;
  <D.7543>:
  D.7542 = p + 1;
  D.7545 = *D.7542;
  if (D.7545 == 62) goto <D.7546>; else goto <D.7547>;
  <D.7546>:
  *full_stop = 0;
  D.7534 = p + 1;
  return D.7534;
  <D.7547>:
  <D.7544>:
  <D.7541>:
  <D.7539>:
  D.7535 = *p;
  if (D.7535 == 47) goto <D.7549>; else goto <D.7548>;
  <D.7549>:
  D.7542 = p + 1;
  if (D.7542 < end) goto <D.7550>; else goto <D.7548>;
  <D.7550>:
  D.7542 = p + 1;
  D.7545 = *D.7542;
  if (D.7545 == 62) goto <D.7551>; else goto <D.7548>;
  <D.7551>:
  *full_stop = 1;
  D.7534 = p + 1;
  return D.7534;
  <D.7548>:
  {
    char * name;
    char * value;

    try
      {
        p = parse_name (p, end, &name);
        if (p == end) goto <D.7552>; else goto <D.7553>;
        <D.7552>:
        D.7534 = p;
        return D.7534;
        <D.7553>:
        p = skip_space (p, end);
        if (p == end) goto <D.7554>; else goto <D.7555>;
        <D.7554>:
        name.9 = name;
        monoeg_g_free (name.9);
        D.7534 = p;
        return D.7534;
        <D.7555>:
        D.7535 = *p;
        if (D.7535 != 61) goto <D.7557>; else goto <D.7558>;
        <D.7557>:
        if (error != 0B) goto <D.7559>; else goto <D.7560>;
        <D.7559>:
        name.9 = name;
        D.7561 = monoeg_g_error_new (1B, 1, "Expected an = after the attribute name `%s\'", name.9);
        *error = D.7561;
        <D.7560>:
        name.9 = name;
        monoeg_g_free (name.9);
        D.7534 = end;
        return D.7534;
        <D.7558>:
        p = p + 1;
        p = skip_space (p, end);
        if (p == end) goto <D.7562>; else goto <D.7563>;
        <D.7562>:
        name.9 = name;
        monoeg_g_free (name.9);
        D.7534 = end;
        return D.7534;
        <D.7563>:
        p = parse_value (p, end, &value, error);
        if (p == end) goto <D.7564>; else goto <D.7565>;
        <D.7564>:
        name.9 = name;
        monoeg_g_free (name.9);
        D.7534 = p;
        return D.7534;
        <D.7565>:
        nnames = nnames + 1;
        D.7566 = *names;
        D.7567 = nnames + 1;
        D.7568 = (unsigned int) D.7567;
        D.7569 = D.7568 * 4;
        D.7570 = monoeg_realloc (D.7566, D.7569);
        *names = D.7570;
        D.7571 = *values;
        D.7567 = nnames + 1;
        D.7568 = (unsigned int) D.7567;
        D.7569 = D.7568 * 4;
        D.7572 = monoeg_realloc (D.7571, D.7569);
        *values = D.7572;
        D.7566 = *names;
        nnames.10 = (sizetype) nnames;
        D.7574 = nnames.10 + 1073741823;
        D.7575 = D.7574 * 4;
        D.7576 = D.7566 + D.7575;
        name.9 = name;
        *D.7576 = name.9;
        D.7571 = *values;
        nnames.10 = (sizetype) nnames;
        D.7574 = nnames.10 + 1073741823;
        D.7575 = D.7574 * 4;
        D.7577 = D.7571 + D.7575;
        value.11 = value;
        *D.7577 = value.11;
        D.7566 = *names;
        nnames.12 = (unsigned int) nnames;
        D.7580 = nnames.12 * 4;
        D.7581 = D.7566 + D.7580;
        *D.7581 = 0B;
        D.7571 = *values;
        nnames.12 = (unsigned int) nnames;
        D.7580 = nnames.12 * 4;
        D.7582 = D.7571 + D.7580;
        *D.7582 = 0B;
      }
    finally
      {
        name = {CLOBBER};
        value = {CLOBBER};
      }
  }
  goto <D.7255>;
}


parse_name (const char * p, const char * end, char * * value)
{
  char D.7587;
  int D.7588;
  const char * D.7591;
  int p.13;
  int start.14;
  int D.7594;
  unsigned int D.7595;
  void * D.7596;
  char * D.7597;
  unsigned int l.15;
  sizetype l.16;
  char * D.7602;
  const char * start;
  int l;

  start = p;
  goto <D.7241>;
  <D.7240>:
  p = p + 1;
  <D.7241>:
  if (p < end) goto <D.7586>; else goto <D.7242>;
  <D.7586>:
  D.7587 = *p;
  D.7588 = my_isalnum (D.7587);
  if (D.7588 != 0) goto <D.7240>; else goto <D.7242>;
  <D.7242>:
  if (p == end) goto <D.7589>; else goto <D.7590>;
  <D.7589>:
  D.7591 = end;
  return D.7591;
  <D.7590>:
  p.13 = (int) p;
  start.14 = (int) start;
  l = p.13 - start.14;
  D.7594 = l + 1;
  D.7595 = (unsigned int) D.7594;
  D.7596 = monoeg_malloc (D.7595);
  *value = D.7596;
  D.7597 = *value;
  if (D.7597 == 0B) goto <D.7598>; else goto <D.7599>;
  <D.7598>:
  D.7591 = end;
  return D.7591;
  <D.7599>:
  D.7597 = *value;
  l.15 = (unsigned int) l;
  strncpy (D.7597, start, l.15);
  D.7597 = *value;
  l.16 = (sizetype) l;
  D.7602 = D.7597 + l.16;
  *D.7602 = 0;
  D.7591 = p;
  return D.7591;
}


skip_space (const char * p, const char * end)
{
  char D.7605;
  int D.7606;
  const char * D.7607;

  goto <D.7220>;
  <D.7219>:
  p = p + 1;
  <D.7220>:
  if (p < end) goto <D.7604>; else goto <D.7221>;
  <D.7604>:
  D.7605 = *p;
  D.7606 = my_isspace (D.7605);
  if (D.7606 != 0) goto <D.7219>; else goto <D.7221>;
  <D.7221>:
  D.7607 = p;
  return D.7607;
}


parse_value (const char * p, const char * end, char * * value, struct GError * * error)
{
  char D.7609;
  struct GError * D.7614;
  const char * D.7615;
  int p.17;
  int start.18;
  int D.7621;
  unsigned int D.7622;
  void * D.7623;
  char * D.7624;
  unsigned int l.19;
  sizetype l.20;
  char * D.7629;
  const char * start;
  int l;

  D.7609 = *p;
  if (D.7609 != 34) goto <D.7610>; else goto <D.7611>;
  <D.7610>:
  if (error != 0B) goto <D.7612>; else goto <D.7613>;
  <D.7612>:
  D.7614 = monoeg_g_error_new (1B, 1, "%s", "Expected the attribute value to start with a quote");
  *error = D.7614;
  <D.7613>:
  D.7615 = end;
  return D.7615;
  <D.7611>:
  p = p + 1;
  start = p;
  goto <D.7231>;
  <D.7230>:
  p = p + 1;
  <D.7231>:
  if (p < end) goto <D.7616>; else goto <D.7232>;
  <D.7616>:
  D.7609 = *p;
  if (D.7609 != 34) goto <D.7230>; else goto <D.7232>;
  <D.7232>:
  if (p == end) goto <D.7617>; else goto <D.7618>;
  <D.7617>:
  D.7615 = end;
  return D.7615;
  <D.7618>:
  p.17 = (int) p;
  start.18 = (int) start;
  l = p.17 - start.18;
  p = p + 1;
  D.7621 = l + 1;
  D.7622 = (unsigned int) D.7621;
  D.7623 = monoeg_malloc (D.7622);
  *value = D.7623;
  D.7624 = *value;
  if (D.7624 == 0B) goto <D.7625>; else goto <D.7626>;
  <D.7625>:
  D.7615 = end;
  return D.7615;
  <D.7626>:
  D.7624 = *value;
  l.19 = (unsigned int) l;
  strncpy (D.7624, start, l.19);
  D.7624 = *value;
  l.20 = (sizetype) l;
  D.7629 = D.7624 + l.20;
  *D.7629 = 0;
  D.7615 = p;
  return D.7615;
}


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

  D.7632 = __builtin_object_size (__dest, 1);
  D.7631 = __builtin___strncpy_chk (__dest, __src, __len, D.7632);
  return D.7631;
}


destroy_parse_state (struct GMarkupParseContext * context)
{
  void * D.7634;
  struct GSList * D.7635;
  struct GString * D.7636;
  struct GSList * p;

  p = context->level;
  goto <D.7261>;
  <D.7260>:
  D.7634 = p->data;
  monoeg_g_free (D.7634);
  p = p->next;
  <D.7261>:
  if (p != 0B) goto <D.7260>; else goto <D.7262>;
  <D.7262>:
  D.7635 = context->level;
  monoeg_g_slist_free (D.7635);
  D.7636 = context->text;
  if (D.7636 != 0B) goto <D.7637>; else goto <D.7638>;
  <D.7637>:
  D.7636 = context->text;
  monoeg_g_string_free (D.7636, 1);
  <D.7638>:
  context->text = 0B;
  context->level = 0B;
}


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

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