mono_profiler_startup (const char * desc)
{
  struct GHashTable * D.8073;
  int D.8076;
  const char * D.8078;
  char D.8079;
  const gchar * D.8081;
  gchar * D.8082;
  char * D.8083;
  char * D.8086;
  gchar * D.8087;
  struct MonoProfiler * prof;

  prof = monoeg_malloc0 (40);
  D.8073 = monoeg_g_hash_table_new (0B, 0B);
  prof->hash = D.8073;
  D.8076 = strncmp ("cov:", desc, 4);
  if (D.8076 == 0) goto <D.8077>; else goto <D.8074>;
  <D.8077>:
  D.8078 = desc + 4;
  D.8079 = *D.8078;
  if (D.8079 != 0) goto <D.8080>; else goto <D.8074>;
  <D.8080>:
  {
    char * cname;

    D.8081 = desc + 4;
    D.8082 = monoeg_strdup (D.8081);
    prof->assembly_name = D.8082;
    D.8083 = prof->assembly_name;
    cname = __builtin_strchr (D.8083, 47);
    if (cname != 0B) goto <D.8084>; else goto <D.8085>;
    <D.8084>:
    *cname = 0;
    D.8086 = cname + 1;
    prof->class_name = D.8086;
    <D.8085>:
  }
  goto <D.8075>;
  <D.8074>:
  D.8087 = monoeg_strdup ("mscorlib");
  prof->assembly_name = D.8087;
  <D.8075>:
  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.8092;

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


cov_shutdown (struct MonoProfiler * prof)
{
  struct MonoAssembly * D.8093;
  char * D.8096;
  int D.8097;
  unsigned int D.8098;
  unsigned int D.8101;
  unsigned int D.8102;
  char * D.8105;
  char D.8108;
  const char * D.8111;
  char * D.8112;
  const char * D.8115;
  char * D.8116;
  struct GHashTable * D.8119;
  void * D.8120;
  int D.8123;
  struct MonoImage * image;
  struct MonoMethod * method;
  int i;
  char * name;

  mono_assembly_foreach (get_assembly, prof);
  D.8093 = prof->assembly;
  if (D.8093 == 0B) goto <D.8094>; else goto <D.8095>;
  <D.8094>:
  D.8096 = prof->assembly_name;
  monoeg_g_print ("Assembly \'%s\' was not loaded\n", D.8096);
  return;
  <D.8095>:
  D.8093 = prof->assembly;
  image = mono_assembly_get_image (D.8093);
  i = 1;
  goto <D.8046>;
  <D.8045>:
  {
    struct MonoClass * klass;

    D.8097 = i | 100663296;
    D.8098 = (unsigned int) D.8097;
    method = mono_get_method (image, D.8098, 0B);
    if (method == 0B) goto <D.8099>; else goto <D.8100>;
    <D.8099>:
    // predicted unlikely by continue predictor.
    goto <D.8044>;
    <D.8100>:
    D.8101 = mono_method_get_flags (method, 0B);
    D.8102 = D.8101 & 1024;
    if (D.8102 != 0) goto <D.8103>; else goto <D.8104>;
    <D.8103>:
    // predicted unlikely by continue predictor.
    goto <D.8044>;
    <D.8104>:
    D.8105 = prof->class_name;
    if (D.8105 != 0B) goto <D.8106>; else goto <D.8107>;
    <D.8106>:
    D.8105 = prof->class_name;
    D.8108 = *D.8105;
    if (D.8108 != 0) goto <D.8109>; else goto <D.8110>;
    <D.8109>:
    klass = mono_method_get_class (method);
    D.8111 = mono_class_get_name (klass);
    D.8105 = prof->class_name;
    D.8112 = strstr (D.8111, D.8105);
    if (D.8112 == 0B) goto <D.8113>; else goto <D.8114>;
    <D.8113>:
    D.8115 = mono_class_get_namespace (klass);
    D.8105 = prof->class_name;
    D.8116 = strstr (D.8115, D.8105);
    if (D.8116 == 0B) goto <D.8117>; else goto <D.8118>;
    <D.8117>:
    // predicted unlikely by continue predictor.
    goto <D.8044>;
    <D.8118>:
    <D.8114>:
    <D.8110>:
    <D.8107>:
    D.8119 = prof->hash;
    D.8120 = monoeg_g_hash_table_lookup (D.8119, method);
    if (D.8120 != 0B) goto <D.8121>; else goto <D.8122>;
    <D.8121>:
    check_partial_coverage (prof, method);
    // predicted unlikely by continue predictor.
    goto <D.8044>;
    <D.8122>:
    name = mono_method_full_name (method, 1);
    monoeg_g_print ("Not covered: %s\n", name);
    monoeg_g_free (name);
  }
  <D.8044>:
  i = i + 1;
  <D.8046>:
  D.8123 = mono_image_get_table_rows (image, 6);
  if (D.8123 >= i) goto <D.8045>; else goto <D.8047>;
  <D.8047>:
}


get_assembly (struct MonoAssembly * ass, struct MonoProfiler * prof)
{
  int D.8021;
  char * D.8134;
  struct MonoImage * D.8135;
  const char * D.8136;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.8134 = prof->assembly_name;
    D.8135 = mono_assembly_get_image (ass);
    D.8136 = mono_image_get_name (D.8135);
    D.8021 = __builtin_strcmp (D.8134, D.8136);
  }
  if (D.8021 == 0) goto <D.8137>; else goto <D.8138>;
  <D.8137>:
  prof->assembly = ass;
  <D.8138>:
}


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

  mono_profiler_coverage_get (prof, method, coverage_callback);
  D.8141 = prof->bb_coverage;
  if (D.8141 != 0B) goto <D.8142>; else goto <D.8143>;
  <D.8142>:
  {
    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.8034>;
    <D.8033>:
    D.8144 = tmp->data;
    monoeg_g_print ("\t%s\n", D.8144);
    D.8144 = tmp->data;
    monoeg_g_free (D.8144);
    tmp = tmp->next;
    <D.8034>:
    if (tmp != 0B) goto <D.8033>; else goto <D.8035>;
    <D.8035>:
    D.8141 = prof->bb_coverage;
    monoeg_g_list_free (D.8141);
    prof->bb_coverage = 0B;
  }
  <D.8143>:
}


coverage_callback (struct MonoProfiler * prof, const struct MonoProfileCoverageEntry * entry)
{
  int D.8146;
  const char * D.8149;
  int D.8152;
  int D.8153;
  int D.8154;
  struct GList * D.8156;
  struct GList * D.8157;
  char * cmsg;

  D.8146 = entry->counter;
  if (D.8146 != 0) goto <D.8147>; else goto <D.8148>;
  <D.8147>:
  return;
  <D.8148>:
  D.8149 = entry->filename;
  if (D.8149 != 0B) goto <D.8150>; else goto <D.8151>;
  <D.8150>:
  D.8152 = entry->iloffset;
  D.8149 = entry->filename;
  D.8153 = entry->line;
  D.8154 = entry->col;
  cmsg = monoeg_g_strdup_printf ("offset 0x%04x (%s: line: %d, col: %d)", D.8152, D.8149, D.8153, D.8154);
  goto <D.8155>;
  <D.8151>:
  D.8152 = entry->iloffset;
  cmsg = monoeg_g_strdup_printf ("offset 0x%04x", D.8152);
  <D.8155>:
  D.8156 = prof->bb_coverage;
  D.8157 = monoeg_g_list_append (D.8156, cmsg);
  prof->bb_coverage = D.8157;
}


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

  if (str != 0B) goto <D.8162>; else goto <D.8163>;
  <D.8162>:
  D.8164 = __strdup (str);
  return D.8164;
  <D.8163>:
  D.8164 = 0B;
  return D.8164;
}