mono_profiler_startup (const char * desc)
{
  struct GHashTable * D.7559;
  int D.7562;
  const char * D.7564;
  char D.7565;
  const gchar * D.7567;
  gchar * D.7568;
  char * D.7569;
  char * D.7572;
  gchar * D.7573;
  struct MonoProfiler * prof;

  prof = monoeg_malloc0 (40);
  D.7559 = monoeg_g_hash_table_new (0B, 0B);
  prof->hash = D.7559;
  D.7562 = strncmp ("cov:", desc, 4);
  if (D.7562 == 0) goto <D.7563>; else goto <D.7560>;
  <D.7563>:
  D.7564 = desc + 4;
  D.7565 = *D.7564;
  if (D.7565 != 0) goto <D.7566>; else goto <D.7560>;
  <D.7566>:
  {
    char * cname;

    D.7567 = desc + 4;
    D.7568 = monoeg_strdup (D.7567);
    prof->assembly_name = D.7568;
    D.7569 = prof->assembly_name;
    cname = __builtin_strchr (D.7569, 47);
    if (cname != 0B) goto <D.7570>; else goto <D.7571>;
    <D.7570>:
    *cname = 0;
    D.7572 = cname + 1;
    prof->class_name = D.7572;
    <D.7571>:
  }
  goto <D.7561>;
  <D.7560>:
  D.7573 = monoeg_strdup ("mscorlib");
  prof->assembly_name = D.7573;
  <D.7561>:
  mono_profiler_install (prof, cov_shutdown);
  mono_profiler_install_enter_leave (cov_method_enter, cov_method_leave);
  mono_profiler_set_events (12288);
}


cov_method_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{

}


cov_method_enter (struct MonoProfiler * prof, struct MonoMethod * method)
{
  struct GHashTable * D.7578;

  D.7578 = prof->hash;
  monoeg_g_hash_table_insert_replace (D.7578, method, 1B, 0);
}


cov_shutdown (struct MonoProfiler * prof)
{
  struct MonoAssembly * D.7579;
  char * D.7582;
  int D.7583;
  unsigned int D.7584;
  unsigned int D.7587;
  unsigned int D.7588;
  char * D.7591;
  char D.7594;
  const char * D.7597;
  char * D.7598;
  const char * D.7601;
  char * D.7602;
  struct GHashTable * D.7605;
  void * D.7606;
  int D.7609;
  struct MonoImage * image;
  struct MonoMethod * method;
  int i;
  char * name;

  mono_assembly_foreach (get_assembly, prof);
  D.7579 = prof->assembly;
  if (D.7579 == 0B) goto <D.7580>; else goto <D.7581>;
  <D.7580>:
  D.7582 = prof->assembly_name;
  monoeg_g_print ("Assembly \'%s\' was not loaded\n", D.7582);
  return;
  <D.7581>:
  D.7579 = prof->assembly;
  image = mono_assembly_get_image (D.7579);
  i = 1;
  goto <D.7532>;
  <D.7531>:
  {
    struct MonoClass * klass;

    D.7583 = i | 100663296;
    D.7584 = (unsigned int) D.7583;
    method = mono_get_method (image, D.7584, 0B);
    if (method == 0B) goto <D.7585>; else goto <D.7586>;
    <D.7585>:
    // predicted unlikely by continue predictor.
    goto <D.7530>;
    <D.7586>:
    D.7587 = mono_method_get_flags (method, 0B);
    D.7588 = D.7587 & 1024;
    if (D.7588 != 0) goto <D.7589>; else goto <D.7590>;
    <D.7589>:
    // predicted unlikely by continue predictor.
    goto <D.7530>;
    <D.7590>:
    D.7591 = prof->class_name;
    if (D.7591 != 0B) goto <D.7592>; else goto <D.7593>;
    <D.7592>:
    D.7591 = prof->class_name;
    D.7594 = *D.7591;
    if (D.7594 != 0) goto <D.7595>; else goto <D.7596>;
    <D.7595>:
    klass = mono_method_get_class (method);
    D.7591 = prof->class_name;
    D.7597 = mono_class_get_name (klass);
    D.7598 = strstr (D.7597, D.7591);
    if (D.7598 == 0B) goto <D.7599>; else goto <D.7600>;
    <D.7599>:
    D.7591 = prof->class_name;
    D.7601 = mono_class_get_namespace (klass);
    D.7602 = strstr (D.7601, D.7591);
    if (D.7602 == 0B) goto <D.7603>; else goto <D.7604>;
    <D.7603>:
    // predicted unlikely by continue predictor.
    goto <D.7530>;
    <D.7604>:
    <D.7600>:
    <D.7596>:
    <D.7593>:
    D.7605 = prof->hash;
    D.7606 = monoeg_g_hash_table_lookup (D.7605, method);
    if (D.7606 != 0B) goto <D.7607>; else goto <D.7608>;
    <D.7607>:
    check_partial_coverage (prof, method);
    // predicted unlikely by continue predictor.
    goto <D.7530>;
    <D.7608>:
    name = mono_method_full_name (method, 1);
    monoeg_g_print ("Not covered: %s\n", name);
    monoeg_g_free (name);
  }
  <D.7530>:
  i = i + 1;
  <D.7532>:
  D.7609 = mono_image_get_table_rows (image, 6);
  if (D.7609 >= i) goto <D.7531>; else goto <D.7533>;
  <D.7533>:
}


get_assembly (struct MonoAssembly * ass, struct MonoProfiler * prof)
{
  int D.7507;
  struct MonoImage * D.7620;
  const char * D.7621;
  char * D.7622;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.7620 = mono_assembly_get_image (ass);
    D.7621 = mono_image_get_name (D.7620);
    D.7622 = prof->assembly_name;
    D.7507 = __builtin_strcmp (D.7622, D.7621);
  }
  if (D.7507 == 0) goto <D.7623>; else goto <D.7624>;
  <D.7623>:
  prof->assembly = ass;
  <D.7624>:
}


check_partial_coverage (struct MonoProfiler * prof, struct MonoMethod * method)
{
  struct GList * D.7627;
  void * D.7630;
  struct GList * tmp;

  mono_profiler_coverage_get (prof, method, coverage_callback);
  D.7627 = prof->bb_coverage;
  if (D.7627 != 0B) goto <D.7628>; else goto <D.7629>;
  <D.7628>:
  {
    char * name;

    name = mono_method_full_name (method, 1);
    monoeg_g_print ("Partial coverage: %s\n", name);
    monoeg_g_free (name);
    tmp = prof->bb_coverage;
    goto <D.7520>;
    <D.7519>:
    D.7630 = tmp->data;
    monoeg_g_print ("\t%s\n", D.7630);
    D.7630 = tmp->data;
    monoeg_g_free (D.7630);
    tmp = tmp->next;
    <D.7520>:
    if (tmp != 0B) goto <D.7519>; else goto <D.7521>;
    <D.7521>:
    D.7627 = prof->bb_coverage;
    monoeg_g_list_free (D.7627);
    prof->bb_coverage = 0B;
  }
  <D.7629>:
}


coverage_callback (struct MonoProfiler * prof, const struct MonoProfileCoverageEntry * entry)
{
  int D.7632;
  const char * D.7635;
  int D.7638;
  int D.7639;
  int D.7640;
  struct GList * D.7642;
  struct GList * D.7643;
  char * cmsg;

  D.7632 = entry->counter;
  if (D.7632 != 0) goto <D.7633>; else goto <D.7634>;
  <D.7633>:
  return;
  <D.7634>:
  D.7635 = entry->filename;
  if (D.7635 != 0B) goto <D.7636>; else goto <D.7637>;
  <D.7636>:
  D.7638 = entry->col;
  D.7639 = entry->line;
  D.7635 = entry->filename;
  D.7640 = entry->iloffset;
  cmsg = monoeg_g_strdup_printf ("offset 0x%04x (%s: line: %d, col: %d)", D.7640, D.7635, D.7639, D.7638);
  goto <D.7641>;
  <D.7637>:
  D.7640 = entry->iloffset;
  cmsg = monoeg_g_strdup_printf ("offset 0x%04x", D.7640);
  <D.7641>:
  D.7642 = prof->bb_coverage;
  D.7643 = monoeg_g_list_append (D.7642, cmsg);
  prof->bb_coverage = D.7643;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.7650;

  if (str != 0B) goto <D.7648>; else goto <D.7649>;
  <D.7648>:
  D.7650 = __strdup (str);
  return D.7650;
  <D.7649>:
  D.7650 = 0B;
  return D.7650;
}