__attribute__((visibility ("hidden")))
mono_public_tokens_are_equal (const unsigned char * pubt1, const unsigned char * pubt2)
{
  gboolean D.18284;
  int D.18285;
  _Bool D.18286;

  D.18285 = memcmp (pubt1, pubt2, 16);
  D.18286 = D.18285 == 0;
  D.18284 = (gboolean) D.18286;
  return D.18284;
}


mono_set_assemblies_path (const char * path)
{
  char * * assemblies_path.0;
  char * D.18291;
  char D.18292;
  char * * dest.1;
  const gchar * D.18296;
  int D.18301;
  char * * splitted;
  char * * dest;

  splitted = monoeg_g_strsplit (path, ":", 1000);
  assemblies_path.0 = assemblies_path;
  if (assemblies_path.0 != 0B) goto <D.18289>; else goto <D.18290>;
  <D.18289>:
  assemblies_path.0 = assemblies_path;
  monoeg_g_strfreev (assemblies_path.0);
  <D.18290>:
  dest = splitted;
  assemblies_path = dest;
  goto <D.17461>;
  <D.17460>:
  D.18291 = *splitted;
  D.18292 = *D.18291;
  if (D.18292 != 0) goto <D.18293>; else goto <D.18294>;
  <D.18293>:
  dest.1 = dest;
  dest = dest.1 + 8;
  D.18291 = *splitted;
  *dest.1 = D.18291;
  <D.18294>:
  splitted = splitted + 8;
  <D.17461>:
  D.18291 = *splitted;
  if (D.18291 != 0B) goto <D.17460>; else goto <D.17462>;
  <D.17462>:
  D.18291 = *splitted;
  *dest = D.18291;
  D.18296 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.18296 == 0B) goto <D.18297>; else goto <D.18298>;
  <D.18297>:
  return;
  <D.18298>:
  splitted = assemblies_path;
  goto <D.17464>;
  <D.17463>:
  D.18291 = *splitted;
  D.18292 = *D.18291;
  if (D.18292 != 0) goto <D.18299>; else goto <D.18300>;
  <D.18299>:
  D.18291 = *splitted;
  D.18301 = monoeg_g_file_test (D.18291, 4);
  if (D.18301 == 0) goto <D.18302>; else goto <D.18303>;
  <D.18302>:
  D.18291 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_PATH doesn\'t exist or has wrong permissions.", D.18291);
  <D.18303>:
  <D.18300>:
  splitted = splitted + 8;
  <D.17464>:
  D.18291 = *splitted;
  if (D.18291 != 0B) goto <D.17463>; else goto <D.17465>;
  <D.17465>:
}


mono_assembly_names_equal (struct MonoAssemblyName * l, struct MonoAssemblyName * r)
{
  const char * D.18307;
  const char * D.18309;
  mono_bool D.18310;
  int D.18311;
  const char * D.18314;
  const char * D.18317;
  int D.18320;
  long unsigned int D.18323;
  long unsigned int D.18324;
  long unsigned int D.18325;
  long unsigned int D.18326;
  unsigned char D.18335;
  unsigned char D.18337;
  mono_byte[17] * D.18338;
  mono_byte[17] * D.18339;
  int D.18340;

  D.18307 = l->name;
  if (D.18307 == 0B) goto <D.18305>; else goto <D.18308>;
  <D.18308>:
  D.18309 = r->name;
  if (D.18309 == 0B) goto <D.18305>; else goto <D.18306>;
  <D.18305>:
  D.18310 = 0;
  return D.18310;
  <D.18306>:
  D.18307 = l->name;
  D.18309 = r->name;
  D.18311 = strcmp (D.18307, D.18309);
  if (D.18311 != 0) goto <D.18312>; else goto <D.18313>;
  <D.18312>:
  D.18310 = 0;
  return D.18310;
  <D.18313>:
  D.18314 = l->culture;
  if (D.18314 != 0B) goto <D.18315>; else goto <D.18316>;
  <D.18315>:
  D.18317 = r->culture;
  if (D.18317 != 0B) goto <D.18318>; else goto <D.18319>;
  <D.18318>:
  D.18314 = l->culture;
  D.18317 = r->culture;
  D.18320 = strcmp (D.18314, D.18317);
  if (D.18320 != 0) goto <D.18321>; else goto <D.18322>;
  <D.18321>:
  D.18310 = 0;
  return D.18310;
  <D.18322>:
  <D.18319>:
  <D.18316>:
  D.18323 = BIT_FIELD_REF <*l, 64, 512>;
  D.18324 = D.18323;
  D.18325 = BIT_FIELD_REF <*r, 64, 512>;
  D.18326 = D.18325;
  if (D.18324 != D.18326) goto <D.18327>; else goto <D.18328>;
  <D.18327>:
  D.18323 = BIT_FIELD_REF <*l, 64, 512>;
  D.18324 = D.18323;
  if (D.18324 != 0) goto <D.18329>; else goto <D.18330>;
  <D.18329>:
  D.18325 = BIT_FIELD_REF <*r, 64, 512>;
  D.18326 = D.18325;
  if (D.18326 != 0) goto <D.18331>; else goto <D.18332>;
  <D.18331>:
  D.18310 = 0;
  return D.18310;
  <D.18332>:
  <D.18330>:
  <D.18328>:
  D.18335 = l->public_key_token[0];
  if (D.18335 == 0) goto <D.18333>; else goto <D.18336>;
  <D.18336>:
  D.18337 = r->public_key_token[0];
  if (D.18337 == 0) goto <D.18333>; else goto <D.18334>;
  <D.18333>:
  D.18310 = 1;
  return D.18310;
  <D.18334>:
  D.18338 = &l->public_key_token;
  D.18339 = &r->public_key_token;
  D.18340 = mono_public_tokens_are_equal (D.18338, D.18339);
  if (D.18340 == 0) goto <D.18341>; else goto <D.18342>;
  <D.18341>:
  D.18310 = 0;
  return D.18310;
  <D.18342>:
  D.18310 = 1;
  return D.18310;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.2;
  int iftmp.3;
  int D.18352;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.18345>; else goto <D.18346>;
  <D.18345>:
  if (__ret == 1) goto <D.18348>; else goto <D.18349>;
  <D.18348>:
  iftmp.3 = -1;
  goto <D.18350>;
  <D.18349>:
  iftmp.3 = 1;
  <D.18350>:
  iftmp.2 = iftmp.3;
  goto <D.18351>;
  <D.18346>:
  iftmp.2 = 0;
  <D.18351>:
  __ret = iftmp.2;
  D.18352 = __ret;
  return D.18352;
}


mono_assembly_setrootdir (const char * root_dir)
{
  gchar * D.18354;

  D.18354 = monoeg_strdup (root_dir);
  default_path[0] = D.18354;
}


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

  if (str != 0B) goto <D.18355>; else goto <D.18356>;
  <D.18355>:
  D.18357 = __strdup (str);
  return D.18357;
  <D.18356>:
  D.18357 = 0B;
  return D.18357;
}


mono_assembly_getrootdir ()
{
  const char * D.18359;

  D.18359 = default_path[0];
  return D.18359;
}


mono_set_dirs (const char * assembly_dir, const char * config_dir)
{
  if (assembly_dir == 0B) goto <D.18361>; else goto <D.18362>;
  <D.18361>:
  assembly_dir = "/usr/lib";
  <D.18362>:
  if (config_dir == 0B) goto <D.18363>; else goto <D.18364>;
  <D.18363>:
  config_dir = "/etc";
  <D.18364>:
  mono_assembly_setrootdir (assembly_dir);
  mono_set_config_dir (config_dir);
}


mono_set_rootdir ()
{
  long int D.18365;
  int D.18368;
  long int D.18369;
  char buf[4096];
  int s;
  char * str;

  try
    {
      D.18365 = readlink ("/proc/self/exe", &buf, 4095);
      s = (int) D.18365;
      if (s != -1) goto <D.18366>; else goto <D.18367>;
      <D.18366>:
      buf[s] = 0;
      set_dirs (&buf);
      return;
      <D.18367>:
      D.18368 = getpid ();
      str = monoeg_g_strdup_printf ("/proc/%d/path/a.out", D.18368);
      D.18369 = readlink (str, &buf, 4095);
      s = (int) D.18369;
      monoeg_g_free (str);
      if (s != -1) goto <D.18370>; else goto <D.18371>;
      <D.18370>:
      buf[s] = 0;
      set_dirs (&buf);
      return;
      <D.18371>:
      fallback ();
    }
  finally
    {
      buf = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  long unsigned int D.18375;
  int D.18378;
  ssize_t D.18381;
  long unsigned int D.18382;
  long unsigned int D.18383;
  long unsigned int D.18386;

  D.18375 = __builtin_object_size (__buf, 1);
  if (D.18375 != 18446744073709551615) goto <D.18376>; else goto <D.18377>;
  <D.18376>:
  D.18378 = __builtin_constant_p (__len);
  if (D.18378 == 0) goto <D.18379>; else goto <D.18380>;
  <D.18379>:
  D.18382 = __builtin_object_size (__buf, 1);
  D.18381 = __readlink_chk (__path, __buf, __len, D.18382);
  return D.18381;
  <D.18380>:
  D.18383 = __builtin_object_size (__buf, 1);
  if (D.18383 < __len) goto <D.18384>; else goto <D.18385>;
  <D.18384>:
  D.18386 = __builtin_object_size (__buf, 1);
  D.18381 = __readlink_chk_warn (__path, __buf, __len, D.18386);
  return D.18381;
  <D.18385>:
  <D.18377>:
  D.18381 = __readlink_alias (__path, __buf, __len);
  return D.18381;
}


__attribute__((__unused__))
set_dirs (char * exe)
{
  long unsigned int D.18390;
  int D.18391;
  int D.18393;
  char * base;
  char * config;
  char * lib;
  char * mono;
  struct stat buf;

  try
    {
      D.18390 = __strlen_g ("/usr/bin/");
      D.18391 = strncmp (exe, "/usr/bin/", D.18390);
      if (D.18391 == 0) goto <D.18388>; else goto <D.18392>;
      <D.18392>:
      base = compute_base (exe);
      if (base == 0B) goto <D.18388>; else goto <D.18389>;
      <D.18388>:
      fallback ();
      return;
      <D.18389>:
      config = monoeg_g_build_path ("/", base, "etc", 0B);
      lib = monoeg_g_build_path ("/", base, "lib", 0B);
      mono = monoeg_g_build_path ("/", lib, "mono/2.0", 0B);
      D.18393 = stat (mono, &buf);
      if (D.18393 == -1) goto <D.18394>; else goto <D.18395>;
      <D.18394>:
      fallback ();
      goto <D.18396>;
      <D.18395>:
      mono_set_dirs (lib, config);
      <D.18396>:
      monoeg_g_free (config);
      monoeg_g_free (lib);
      monoeg_g_free (mono);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.18400;
  long int __ptr.4;
  long int __str.5;
  long int D.18403;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.4 = (long int) __ptr;
  __str.5 = (long int) __str;
  D.18403 = __ptr.4 - __str.5;
  D.18400 = (size_t) D.18403;
  return D.18400;
}


compute_base (char * path)
{
  char * D.18407;
  int D.18408;
  int D.18411;
  int D.18414;
  int D.18417;
  int D.18420;
  int D.18423;
  int D.18428;
  char * p;

  p = strrchr (path, 47);
  if (p == 0B) goto <D.18405>; else goto <D.18406>;
  <D.18405>:
  D.18407 = 0B;
  return D.18407;
  <D.18406>:
  D.18408 = strcmp (p, "/mono");
  if (D.18408 != 0) goto <D.18409>; else goto <D.18410>;
  <D.18409>:
  D.18411 = strcmp (p, "/mono-sgen");
  if (D.18411 != 0) goto <D.18412>; else goto <D.18413>;
  <D.18412>:
  D.18414 = strcmp (p, "/pedump");
  if (D.18414 != 0) goto <D.18415>; else goto <D.18416>;
  <D.18415>:
  D.18417 = strcmp (p, "/monodis");
  if (D.18417 != 0) goto <D.18418>; else goto <D.18419>;
  <D.18418>:
  D.18420 = strcmp (p, "/mint");
  if (D.18420 != 0) goto <D.18421>; else goto <D.18422>;
  <D.18421>:
  D.18423 = strcmp (p, "/monodiet");
  if (D.18423 != 0) goto <D.18424>; else goto <D.18425>;
  <D.18424>:
  D.18407 = 0B;
  return D.18407;
  <D.18425>:
  <D.18422>:
  <D.18419>:
  <D.18416>:
  <D.18413>:
  <D.18410>:
  *p = 0;
  p = strrchr (path, 47);
  if (p == 0B) goto <D.18426>; else goto <D.18427>;
  <D.18426>:
  D.18407 = 0B;
  return D.18407;
  <D.18427>:
  D.18428 = strcmp (p, "/bin");
  if (D.18428 != 0) goto <D.18429>; else goto <D.18430>;
  <D.18429>:
  D.18407 = 0B;
  return D.18407;
  <D.18430>:
  *p = 0;
  D.18407 = path;
  return D.18407;
}


__attribute__((__gnu_inline__, __leaf__, __nothrow__))
stat (const char * __path, struct stat * __statbuf)
{
  int D.18432;

  D.18432 = __xstat (1, __path, __statbuf);
  return D.18432;
}


fallback ()
{
  mono_set_dirs ("/usr/lib", "/etc");
}


mono_assemblies_init ()
{
  const char * D.18434;

  D.18434 = mono_assembly_getrootdir ();
  if (D.18434 == 0B) goto <D.18435>; else goto <D.18436>;
  <D.18435>:
  mono_set_rootdir ();
  <D.18436>:
  check_path_env ();
  check_extra_gac_path_env ();
  InitializeCriticalSection (&assemblies_mutex);
  pthread_mutex_init (&assembly_binding_mutex, 0B);
}


check_path_env ()
{
  char * * assemblies_path.6;
  const char * path;

  path = monoeg_g_getenv ("MONO_PATH");
  if (path == 0B) goto <D.18437>; else goto <D.18439>;
  <D.18439>:
  assemblies_path.6 = assemblies_path;
  if (assemblies_path.6 != 0B) goto <D.18437>; else goto <D.18438>;
  <D.18437>:
  return;
  <D.18438>:
  mono_set_assemblies_path (path);
}


check_extra_gac_path_env ()
{
  char * * extra_gac_paths.7;
  char * D.18447;
  char D.18448;
  char * * dest.8;
  const gchar * D.18452;
  int D.18457;
  const char * path;
  char * * splitted;
  char * * dest;

  path = monoeg_g_getenv ("MONO_GAC_PREFIX");
  if (path == 0B) goto <D.18442>; else goto <D.18443>;
  <D.18442>:
  return;
  <D.18443>:
  splitted = monoeg_g_strsplit (path, ":", 1000);
  extra_gac_paths.7 = extra_gac_paths;
  if (extra_gac_paths.7 != 0B) goto <D.18445>; else goto <D.18446>;
  <D.18445>:
  extra_gac_paths.7 = extra_gac_paths;
  monoeg_g_strfreev (extra_gac_paths.7);
  <D.18446>:
  dest = splitted;
  extra_gac_paths = dest;
  goto <D.17477>;
  <D.17476>:
  D.18447 = *splitted;
  D.18448 = *D.18447;
  if (D.18448 != 0) goto <D.18449>; else goto <D.18450>;
  <D.18449>:
  dest.8 = dest;
  dest = dest.8 + 8;
  D.18447 = *splitted;
  *dest.8 = D.18447;
  <D.18450>:
  splitted = splitted + 8;
  <D.17477>:
  D.18447 = *splitted;
  if (D.18447 != 0B) goto <D.17476>; else goto <D.17478>;
  <D.17478>:
  D.18447 = *splitted;
  *dest = D.18447;
  D.18452 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.18452 == 0B) goto <D.18453>; else goto <D.18454>;
  <D.18453>:
  return;
  <D.18454>:
  goto <D.17480>;
  <D.17479>:
  D.18447 = *splitted;
  D.18448 = *D.18447;
  if (D.18448 != 0) goto <D.18455>; else goto <D.18456>;
  <D.18455>:
  D.18447 = *splitted;
  D.18457 = monoeg_g_file_test (D.18447, 4);
  if (D.18457 == 0) goto <D.18458>; else goto <D.18459>;
  <D.18458>:
  D.18447 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_GAC_PREFIX doesn\'t exist or has wrong permissions.", D.18447);
  <D.18459>:
  <D.18456>:
  splitted = splitted + 8;
  <D.17480>:
  D.18447 = *splitted;
  if (D.18447 != 0B) goto <D.17479>; else goto <D.17481>;
  <D.17481>:
}


mono_assembly_fill_assembly_name (struct MonoImage * image, struct MonoAssemblyName * aname)
{
  long unsigned int D.18461;
  long unsigned int D.18462;
  mono_bool D.18465;
  unsigned int D.18466;
  const char * D.18467;
  unsigned int D.18468;
  const char * D.18469;
  unsigned int D.18470;
  unsigned int D.18471;
  short unsigned int D.18472;
  unsigned int D.18473;
  short unsigned int D.18474;
  unsigned int D.18475;
  short unsigned int D.18476;
  unsigned int D.18477;
  short unsigned int D.18478;
  unsigned int D.18479;
  unsigned int D.18480;
  const char * pkey.9;
  const gchar * pkey.10;
  unsigned int D.18485;
  const mono_byte * D.18486;
  unsigned int len.11;
  mono_byte[17] * D.18488;
  const char * D.18492;
  void * D.18494;
  short unsigned int D.18495;
  unsigned int D.18496;
  int D.18497;
  int D.18501;
  struct MonoTableInfo * t;
  guint32 cols[9];
  gint32 machine;
  gint32 flags;

  try
    {
      t = &image->tables[32];
      D.18461 = BIT_FIELD_REF <*t, 64, 64>;
      D.18462 = D.18461 & 18446742974197923840;
      if (D.18462 == 0) goto <D.18463>; else goto <D.18464>;
      <D.18463>:
      D.18465 = 0;
      return D.18465;
      <D.18464>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      aname->hash_len = 0;
      aname->hash_value = 0B;
      D.18466 = cols[7];
      D.18467 = mono_metadata_string_heap (image, D.18466);
      aname->name = D.18467;
      D.18468 = cols[8];
      D.18469 = mono_metadata_string_heap (image, D.18468);
      aname->culture = D.18469;
      D.18470 = cols[5];
      aname->flags = D.18470;
      D.18471 = cols[1];
      D.18472 = (short unsigned int) D.18471;
      aname->major = D.18472;
      D.18473 = cols[2];
      D.18474 = (short unsigned int) D.18473;
      aname->minor = D.18474;
      D.18475 = cols[3];
      D.18476 = (short unsigned int) D.18475;
      aname->build = D.18476;
      D.18477 = cols[4];
      D.18478 = (short unsigned int) D.18477;
      aname->revision = D.18478;
      D.18479 = cols[0];
      aname->hash_alg = D.18479;
      D.18480 = cols[6];
      if (D.18480 != 0) goto <D.18481>; else goto <D.18482>;
      <D.18481>:
      {
        guchar * token;
        gchar * encoded;
        const gchar * pkey;
        int len;

        try
          {
            token = monoeg_malloc (8);
            D.18480 = cols[6];
            pkey.9 = mono_metadata_blob_heap (image, D.18480);
            pkey = pkey.9;
            pkey.10 = pkey;
            D.18485 = mono_metadata_decode_blob_size (pkey.10, &pkey);
            len = (int) D.18485;
            pkey.10 = pkey;
            aname->public_key = pkey.10;
            D.18486 = aname->public_key;
            len.11 = (unsigned int) len;
            mono_digest_get_public_token (token, D.18486, len.11);
            encoded = encode_public_tok (token, 8);
            D.18488 = &aname->public_key_token;
            monoeg_g_strlcpy (D.18488, encoded, 17);
            monoeg_g_free (encoded);
            monoeg_g_free (token);
          }
        finally
          {
            pkey = {CLOBBER};
          }
      }
      goto <D.18489>;
      <D.18482>:
      aname->public_key = 0B;
      D.18488 = &aname->public_key_token;
      memset (D.18488, 0, 17);
      <D.18489>:
      D.18480 = cols[6];
      if (D.18480 != 0) goto <D.18490>; else goto <D.18491>;
      <D.18490>:
      D.18480 = cols[6];
      D.18492 = mono_metadata_blob_heap (image, D.18480);
      aname->public_key = D.18492;
      goto <D.18493>;
      <D.18491>:
      aname->public_key = 0B;
      <D.18493>:
      D.18494 = image->image_info;
      D.18495 = MEM[(struct MonoCLIImageInfo *)D.18494].cli_header.coff.coff_machine;
      machine = (gint32) D.18495;
      D.18494 = image->image_info;
      D.18496 = MEM[(struct MonoCLIImageInfo *)D.18494].cli_cli_header.ch_flags;
      flags = (gint32) D.18496;
      switch (machine) <default: <D.17580>, case 332: <D.17575>, case 452: <D.17579>, case 512: <D.17577>, case 34404: <D.17578>>
      <D.17575>:
      D.18497 = flags & 18;
      if (D.18497 != 0) goto <D.18498>; else goto <D.18499>;
      <D.18498>:
      aname->arch = 2;
      goto <D.18500>;
      <D.18499>:
      D.18501 = flags & 112;
      if (D.18501 == 112) goto <D.18502>; else goto <D.18503>;
      <D.18502>:
      aname->arch = 0;
      goto <D.18504>;
      <D.18503>:
      aname->arch = 1;
      <D.18504>:
      <D.18500>:
      goto <D.17576>;
      <D.17577>:
      aname->arch = 3;
      goto <D.17576>;
      <D.17578>:
      aname->arch = 4;
      goto <D.17576>;
      <D.17579>:
      aname->arch = 5;
      goto <D.17576>;
      <D.17580>:
      goto <D.17576>;
      <D.17576>:
      D.18465 = 1;
      return D.18465;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


encode_public_tok (const guchar * token, gint32 len)
{
  int D.18508;
  int D.18509;
  long unsigned int D.18510;
  int D.18511;
  sizetype D.18512;
  gchar * D.18513;
  sizetype D.18514;
  const guchar * D.18515;
  unsigned char D.18516;
  unsigned char D.18517;
  int D.18518;
  char D.18519;
  sizetype D.18520;
  gchar * D.18521;
  int D.18522;
  int D.18523;
  char D.18524;
  sizetype D.18525;
  gchar * D.18526;
  gchar * D.18527;
  static const gchar allowed[16] = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102};
  gchar * res;
  int i;

  D.18508 = len * 2;
  D.18509 = D.18508 + 1;
  D.18510 = (long unsigned int) D.18509;
  res = monoeg_malloc (D.18510);
  i = 0;
  goto <D.17449>;
  <D.17448>:
  D.18511 = i * 2;
  D.18512 = (sizetype) D.18511;
  D.18513 = res + D.18512;
  D.18514 = (sizetype) i;
  D.18515 = token + D.18514;
  D.18516 = *D.18515;
  D.18517 = D.18516 >> 4;
  D.18518 = (int) D.18517;
  D.18519 = allowed[D.18518];
  *D.18513 = D.18519;
  D.18511 = i * 2;
  D.18512 = (sizetype) D.18511;
  D.18520 = D.18512 + 1;
  D.18521 = res + D.18520;
  D.18514 = (sizetype) i;
  D.18515 = token + D.18514;
  D.18516 = *D.18515;
  D.18522 = (int) D.18516;
  D.18523 = D.18522 & 15;
  D.18524 = allowed[D.18523];
  *D.18521 = D.18524;
  i = i + 1;
  <D.17449>:
  if (i < len) goto <D.17448>; else goto <D.17450>;
  <D.17450>:
  D.18508 = len * 2;
  D.18525 = (sizetype) D.18508;
  D.18526 = res + D.18525;
  *D.18526 = 0;
  D.18527 = res;
  return D.18527;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.18529;
  long unsigned int D.18530;

  D.18530 = __builtin_object_size (__dest, 0);
  D.18529 = __builtin___memset_chk (__dest, __ch, __len, D.18530);
  return D.18529;
}


mono_stringify_assembly_name (struct MonoAssemblyName * aname)
{
  const char * iftmp.12;
  const char * D.18535;
  const short unsigned int * * D.18537;
  const short unsigned int * D.18538;
  char D.18539;
  long unsigned int D.18540;
  long unsigned int D.18541;
  const short unsigned int * D.18542;
  short unsigned int D.18543;
  int D.18544;
  int D.18545;
  char * D.18547;
  short unsigned int D.18548;
  int D.18549;
  short unsigned int D.18550;
  int D.18551;
  short unsigned int D.18552;
  int D.18553;
  short unsigned int D.18554;
  int D.18555;
  const char * iftmp.13;
  const char * D.18559;
  char D.18561;
  const char * iftmp.14;
  unsigned char D.18564;
  const char * iftmp.15;
  unsigned int D.18569;
  unsigned int D.18570;
  const char * quote;

  D.18535 = aname->name;
  if (D.18535 != 0B) goto <D.18536>; else goto <D.18533>;
  <D.18536>:
  D.18537 = __ctype_b_loc ();
  D.18538 = *D.18537;
  D.18535 = aname->name;
  D.18539 = *D.18535;
  D.18540 = (long unsigned int) D.18539;
  D.18541 = D.18540 * 2;
  D.18542 = D.18538 + D.18541;
  D.18543 = *D.18542;
  D.18544 = (int) D.18543;
  D.18545 = D.18544 & 32;
  if (D.18545 != 0) goto <D.18546>; else goto <D.18533>;
  <D.18546>:
  iftmp.12 = "\"";
  goto <D.18534>;
  <D.18533>:
  iftmp.12 = "";
  <D.18534>:
  quote = iftmp.12;
  D.18535 = aname->name;
  D.18548 = aname->major;
  D.18549 = (int) D.18548;
  D.18550 = aname->minor;
  D.18551 = (int) D.18550;
  D.18552 = aname->build;
  D.18553 = (int) D.18552;
  D.18554 = aname->revision;
  D.18555 = (int) D.18554;
  D.18559 = aname->culture;
  if (D.18559 != 0B) goto <D.18560>; else goto <D.18557>;
  <D.18560>:
  D.18559 = aname->culture;
  D.18561 = *D.18559;
  if (D.18561 != 0) goto <D.18562>; else goto <D.18557>;
  <D.18562>:
  iftmp.13 = aname->culture;
  goto <D.18558>;
  <D.18557>:
  iftmp.13 = "neutral";
  <D.18558>:
  D.18564 = aname->public_key_token[0];
  if (D.18564 != 0) goto <D.18565>; else goto <D.18566>;
  <D.18565>:
  iftmp.14 = &aname->public_key_token;
  goto <D.18567>;
  <D.18566>:
  iftmp.14 = "null";
  <D.18567>:
  D.18569 = aname->flags;
  D.18570 = D.18569 & 256;
  if (D.18570 != 0) goto <D.18571>; else goto <D.18572>;
  <D.18571>:
  iftmp.15 = ", Retargetable=Yes";
  goto <D.18573>;
  <D.18572>:
  iftmp.15 = "";
  <D.18573>:
  D.18547 = monoeg_g_strdup_printf ("%s%s%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", quote, D.18535, quote, D.18549, D.18551, D.18553, D.18555, iftmp.13, iftmp.14, iftmp.15);
  return D.18547;
}


__attribute__((visibility ("hidden")))
mono_assembly_addref (struct MonoAssembly * assembly)
{
  int * D.18575;

  D.18575 = &assembly->ref_count;
  InterlockedIncrement (D.18575);
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.18576;
  unsigned int D.18577;

  D.18577 = __sync_add_and_fetch_4 (val, 1);
  D.18576 = (gint32) D.18577;
  return D.18576;
}


mono_assembly_get_assemblyref (struct MonoImage * image, int index, struct MonoAssemblyName * aname)
{
  unsigned int D.18579;
  const char * hash.16;
  const char * hash.17;
  unsigned int D.18582;
  unsigned int D.18583;
  const char * D.18584;
  unsigned int D.18585;
  const char * D.18586;
  unsigned int D.18587;
  unsigned int D.18588;
  short unsigned int D.18589;
  unsigned int D.18590;
  short unsigned int D.18591;
  unsigned int D.18592;
  short unsigned int D.18593;
  unsigned int D.18594;
  short unsigned int D.18595;
  unsigned int D.18596;
  unsigned int D.18599;
  mono_byte[17] * D.18600;
  struct MonoTableInfo * t;
  guint32 cols[9];
  const char * hash;

  try
    {
      t = &image->tables[35];
      mono_metadata_decode_row (t, index, &cols, 9);
      D.18579 = cols[8];
      hash.16 = mono_metadata_blob_heap (image, D.18579);
      hash = hash.16;
      hash.17 = hash;
      D.18582 = mono_metadata_decode_blob_size (hash.17, &hash);
      aname->hash_len = D.18582;
      hash.17 = hash;
      aname->hash_value = hash.17;
      D.18583 = cols[6];
      D.18584 = mono_metadata_string_heap (image, D.18583);
      aname->name = D.18584;
      D.18585 = cols[7];
      D.18586 = mono_metadata_string_heap (image, D.18585);
      aname->culture = D.18586;
      D.18587 = cols[4];
      aname->flags = D.18587;
      D.18588 = cols[0];
      D.18589 = (short unsigned int) D.18588;
      aname->major = D.18589;
      D.18590 = cols[1];
      D.18591 = (short unsigned int) D.18590;
      aname->minor = D.18591;
      D.18592 = cols[2];
      D.18593 = (short unsigned int) D.18592;
      aname->build = D.18593;
      D.18594 = cols[3];
      D.18595 = (short unsigned int) D.18594;
      aname->revision = D.18595;
      D.18596 = cols[5];
      if (D.18596 != 0) goto <D.18597>; else goto <D.18598>;
      <D.18597>:
      {
        gchar * token;

        D.18596 = cols[5];
        D.18599 = aname->flags;
        token = assemblyref_public_tok (image, D.18596, D.18599);
        D.18600 = &aname->public_key_token;
        monoeg_g_strlcpy (D.18600, token, 17);
        monoeg_g_free (token);
      }
      goto <D.18601>;
      <D.18598>:
      D.18600 = &aname->public_key_token;
      memset (D.18600, 0, 17);
      <D.18601>:
    }
  finally
    {
      cols = {CLOBBER};
      hash = {CLOBBER};
    }
}


assemblyref_public_tok (struct MonoImage * image, guint32 key_index, guint32 flags)
{
  const char * public_tok.18;
  const gchar * public_tok.19;
  unsigned int D.18604;
  unsigned int D.18605;
  unsigned int len.20;
  gchar * D.18609;
  const gchar * public_tok;
  int len;

  try
    {
      public_tok.18 = mono_metadata_blob_heap (image, key_index);
      public_tok = public_tok.18;
      public_tok.19 = public_tok;
      D.18604 = mono_metadata_decode_blob_size (public_tok.19, &public_tok);
      len = (int) D.18604;
      D.18605 = flags & 1;
      if (D.18605 != 0) goto <D.18606>; else goto <D.18607>;
      <D.18606>:
      {
        guchar token[8];

        try
          {
            public_tok.19 = public_tok;
            len.20 = (unsigned int) len;
            mono_digest_get_public_token (&token, public_tok.19, len.20);
            D.18609 = encode_public_tok (&token, 8);
            return D.18609;
          }
        finally
          {
            token = {CLOBBER};
          }
      }
      <D.18607>:
      public_tok.19 = public_tok;
      D.18609 = encode_public_tok (public_tok.19, len);
      return D.18609;
    }
  finally
    {
      public_tok = {CLOBBER};
    }
}


mono_assembly_load_reference (struct MonoImage * image, int index)
{
  _Bool D.18615;
  long int D.18616;
  long int D.18617;
  struct MonoAssembly * * D.18620;
  <unnamed-unsigned:24> D.18623;
  int D.18624;
  int D.18625;
  long unsigned int D.18626;
  long unsigned int D.18627;
  void * D.18628;
  long unsigned int D.18629;
  long unsigned int D.18630;
  struct MonoAssembly * * D.18631;
  _Bool D.18634;
  long int D.18635;
  long int D.18636;
  struct MonoAssembly * D.18643;
  int D.18645;
  const char * D.18647;
  int D.18648;
  char * D.18651;
  const char * iftmp.21;
  <unnamed type> status.22;
  int * D.18667;
  int D.18668;
  const char * iftmp.23;
  char * D.18676;
  char * D.18684;
  short unsigned int D.18685;
  int D.18686;
  short unsigned int D.18687;
  int D.18688;
  short unsigned int D.18689;
  int D.18690;
  short unsigned int D.18691;
  int D.18692;
  const char * iftmp.24;
  long unsigned int D.18694;
  _Bool D.18700;
  long int D.18701;
  long int D.18702;
  struct MonoAssembly * D.18707;
  const char * D.18714;
  const char * D.18715;
  int D.18716;
  _Bool D.18722;
  long int D.18723;
  long int D.18724;
  struct MonoAssembly * reference;
  struct MonoAssemblyName aname;
  MonoImageOpenStatus status;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18613>; else goto <D.18614>;
        <D.18613>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.18614>:
        D.18615 = ret != 0;
        D.18616 = (long int) D.18615;
        D.18617 = __builtin_expect (D.18616, 0);
        if (D.18617 != 0) goto <D.18618>; else goto <D.18619>;
        <D.18618>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1074, "ret == 0");
        <D.18619>:
      }
      D.18620 = image->references;
      if (D.18620 == 0B) goto <D.18621>; else goto <D.18622>;
      <D.18621>:
      {
        struct MonoTableInfo * t;

        t = &image->tables[35];
        D.18623 = t->rows;
        D.18624 = (int) D.18623;
        D.18625 = D.18624 + 1;
        D.18626 = (long unsigned int) D.18625;
        D.18627 = D.18626 * 8;
        D.18628 = monoeg_malloc0 (D.18627);
        image->references = D.18628;
        D.18623 = t->rows;
        D.18624 = (int) D.18623;
        image->nreferences = D.18624;
      }
      <D.18622>:
      D.18620 = image->references;
      D.18629 = (long unsigned int) index;
      D.18630 = D.18629 * 8;
      D.18631 = D.18620 + D.18630;
      reference = *D.18631;
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18632>; else goto <D.18633>;
        <D.18632>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.18633>:
        D.18634 = ret != 0;
        D.18635 = (long int) D.18634;
        D.18636 = __builtin_expect (D.18635, 0);
        if (D.18636 != 0) goto <D.18637>; else goto <D.18638>;
        <D.18637>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1082, "ret == 0");
        <D.18638>:
      }
      if (reference != 0B) goto <D.18639>; else goto <D.18640>;
      <D.18639>:
      return;
      <D.18640>:
      mono_assembly_get_assemblyref (image, index, &aname);
      D.18643 = image->assembly;
      if (D.18643 != 0B) goto <D.18644>; else goto <D.18641>;
      <D.18644>:
      D.18643 = image->assembly;
      D.18645 = D.18643->ref_only;
      if (D.18645 != 0) goto <D.18646>; else goto <D.18641>;
      <D.18646>:
      D.18647 = aname.name;
      D.18648 = strcmp (D.18647, "mscorlib");
      if (D.18648 == 0) goto <D.18649>; else goto <D.18650>;
      <D.18649>:
      D.18643 = image->assembly;
      D.18651 = D.18643->basedir;
      reference = mono_assembly_load_full (&aname, D.18651, &status, 0);
      goto <D.18652>;
      <D.18650>:
      reference = mono_assembly_loaded_full (&aname, 1);
      if (reference == 0B) goto <D.18653>; else goto <D.18654>;
      <D.18653>:
      reference = mono_assembly_invoke_search_hook_internal (&aname, 1, 1);
      <D.18654>:
      <D.18652>:
      if (reference == 0B) goto <D.18655>; else goto <D.18656>;
      <D.18655>:
      reference = -1B;
      <D.18656>:
      goto <D.18642>;
      <D.18641>:
      D.18643 = image->assembly;
      if (D.18643 != 0B) goto <D.18658>; else goto <D.18659>;
      <D.18658>:
      D.18643 = image->assembly;
      iftmp.21 = D.18643->basedir;
      goto <D.18660>;
      <D.18659>:
      iftmp.21 = 0B;
      <D.18660>:
      reference = mono_assembly_load (&aname, iftmp.21, &status);
      <D.18642>:
      if (reference == 0B) goto <D.18661>; else goto <D.18662>;
      <D.18661>:
      {
        char * extra_msg;

        status.22 = status;
        if (status.22 == 1) goto <D.18666>; else goto <D.18663>;
        <D.18666>:
        D.18667 = __errno_location ();
        D.18668 = *D.18667;
        if (D.18668 == 2) goto <D.18669>; else goto <D.18663>;
        <D.18669>:
        D.18643 = image->assembly;
        if (D.18643 != 0B) goto <D.18671>; else goto <D.18672>;
        <D.18671>:
        D.18643 = image->assembly;
        iftmp.23 = D.18643->basedir;
        goto <D.18673>;
        <D.18672>:
        iftmp.23 = "";
        <D.18673>:
        extra_msg = monoeg_g_strdup_printf ("The assembly was not found in the Global Assembly Cache, a path listed in the MONO_PATH environment variable, or in the location of the executing assembly (%s).\n", iftmp.23);
        goto <D.18664>;
        <D.18663>:
        status.22 = status;
        if (status.22 == 1) goto <D.18674>; else goto <D.18675>;
        <D.18674>:
        D.18667 = __errno_location ();
        D.18668 = *D.18667;
        D.18676 = strerror (D.18668);
        extra_msg = monoeg_g_strdup_printf ("System error: %s\n", D.18676);
        goto <D.18677>;
        <D.18675>:
        status.22 = status;
        if (status.22 == 2) goto <D.18678>; else goto <D.18679>;
        <D.18678>:
        extra_msg = monoeg_strdup ("Cannot find an assembly referenced from this one.\n");
        goto <D.18680>;
        <D.18679>:
        status.22 = status;
        if (status.22 == 3) goto <D.18681>; else goto <D.18682>;
        <D.18681>:
        extra_msg = monoeg_strdup ("The file exists but is not a valid assembly.\n");
        goto <D.18683>;
        <D.18682>:
        extra_msg = monoeg_strdup ("");
        <D.18683>:
        <D.18680>:
        <D.18677>:
        <D.18664>:
        D.18684 = image->name;
        D.18647 = aname.name;
        D.18685 = aname.major;
        D.18686 = (int) D.18685;
        D.18687 = aname.minor;
        D.18688 = (int) D.18687;
        D.18689 = aname.build;
        D.18690 = (int) D.18689;
        D.18691 = aname.revision;
        D.18692 = (int) D.18691;
        D.18694 = __strlen_g (&aname.public_key_token);
        if (D.18694 != 0) goto <D.18695>; else goto <D.18696>;
        <D.18695>:
        iftmp.24 = &aname.public_key_token;
        goto <D.18697>;
        <D.18696>:
        iftmp.24 = "(none)";
        <D.18697>:
        mono_trace (16, 1, "The following assembly referenced from %s could not be loaded:\n     Assembly:   %s    (assemblyref_index=%d)\n     Version:    %d.%d.%d.%d\n     Public Key: %s\n%s", D.18684, D.18647, index, D.18686, D.18688, D.18690, D.18692, iftmp.24, extra_msg);
        monoeg_g_free (extra_msg);
      }
      <D.18662>:
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18698>; else goto <D.18699>;
        <D.18698>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.18699>:
        D.18700 = ret != 0;
        D.18701 = (long int) D.18700;
        D.18702 = __builtin_expect (D.18701, 0);
        if (D.18702 != 0) goto <D.18703>; else goto <D.18704>;
        <D.18703>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1133, "ret == 0");
        <D.18704>:
      }
      if (reference == 0B) goto <D.18705>; else goto <D.18706>;
      <D.18705>:
      reference = -1B;
      <D.18706>:
      D.18620 = image->references;
      D.18629 = (long unsigned int) index;
      D.18630 = D.18629 * 8;
      D.18631 = D.18620 + D.18630;
      D.18707 = *D.18631;
      if (D.18707 == 0B) goto <D.18708>; else goto <D.18709>;
      <D.18708>:
      if (reference != -1B) goto <D.18710>; else goto <D.18711>;
      <D.18710>:
      mono_assembly_addref (reference);
      D.18643 = image->assembly;
      if (D.18643 != 0B) goto <D.18712>; else goto <D.18713>;
      <D.18712>:
      D.18643 = image->assembly;
      D.18714 = D.18643->aname.name;
      D.18643 = image->assembly;
      D.18715 = reference->aname.name;
      D.18716 = reference->ref_count;
      mono_trace (64, 1, "Assembly Ref addref %s[%p] -> %s[%p]: %d", D.18714, D.18643, D.18715, reference, D.18716);
      <D.18713>:
      goto <D.18717>;
      <D.18711>:
      D.18643 = image->assembly;
      if (D.18643 != 0B) goto <D.18718>; else goto <D.18719>;
      <D.18718>:
      D.18643 = image->assembly;
      D.18714 = D.18643->aname.name;
      D.18643 = image->assembly;
      mono_trace (64, 1, "Failed to load assembly %s[%p]\n", D.18714, D.18643);
      <D.18719>:
      <D.18717>:
      D.18620 = image->references;
      D.18629 = (long unsigned int) index;
      D.18630 = D.18629 * 8;
      D.18631 = D.18620 + D.18630;
      *D.18631 = reference;
      <D.18709>:
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18720>; else goto <D.18721>;
        <D.18720>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.18721>:
        D.18722 = ret != 0;
        D.18723 = (long int) D.18722;
        D.18724 = __builtin_expect (D.18723, 0);
        if (D.18724 != 0) goto <D.18725>; else goto <D.18726>;
        <D.18725>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1153, "ret == 0");
        <D.18726>:
      }
      D.18620 = image->references;
      D.18629 = (long unsigned int) index;
      D.18630 = D.18629 * 8;
      D.18631 = D.18620 + D.18630;
      D.18707 = *D.18631;
      if (D.18707 != reference) goto <D.18727>; else goto <D.18728>;
      <D.18727>:
      mono_assembly_close (reference);
      <D.18728>:
    }
  finally
    {
      aname = {CLOBBER};
      status = {CLOBBER};
    }
}


mono_assembly_invoke_search_hook_internal (struct MonoAssemblyName * aname, gboolean refonly, gboolean postload)
{
  int D.18732;
  int D.18735;
  struct MonoAssembly * (*<T1031>) (struct MonoAssemblyName *, void *) D.18738;
  void * D.18739;
  struct MonoAssembly * D.18742;
  struct AssemblySearchHook * hook;

  hook = assembly_search_hook;
  goto <D.17694>;
  <D.17693>:
  D.18732 = hook->refonly;
  if (D.18732 == refonly) goto <D.18733>; else goto <D.18734>;
  <D.18733>:
  D.18735 = hook->postload;
  if (D.18735 == postload) goto <D.18736>; else goto <D.18737>;
  <D.18736>:
  {
    struct MonoAssembly * ass;

    D.18738 = hook->func;
    D.18739 = hook->user_data;
    ass = D.18738 (aname, D.18739);
    if (ass != 0B) goto <D.18740>; else goto <D.18741>;
    <D.18740>:
    D.18742 = ass;
    return D.18742;
    <D.18741>:
  }
  <D.18737>:
  <D.18734>:
  hook = hook->next;
  <D.17694>:
  if (hook != 0B) goto <D.17693>; else goto <D.17695>;
  <D.17695>:
  D.18742 = 0B;
  return D.18742;
}


mono_assembly_load_references (struct MonoImage * image, MonoImageOpenStatus * status)
{
  *status = 0;
}


mono_assembly_invoke_load_hook (struct MonoAssembly * ass)
{
  void (*<T102a>) (struct MonoAssembly *, void *) D.18744;
  void * D.18745;
  struct AssemblyLoadHook * hook;

  hook = assembly_load_hook;
  goto <D.17663>;
  <D.17662>:
  D.18744 = hook->func;
  D.18745 = hook->user_data;
  D.18744 (ass, D.18745);
  hook = hook->next;
  <D.17663>:
  if (hook != 0B) goto <D.17662>; else goto <D.17664>;
  <D.17664>:
}


mono_install_assembly_load_hook (void (*MonoAssemblyLoadFunc) (struct MonoAssembly *, void *) func, void * user_data)
{
  struct AssemblyLoadHook * assembly_load_hook.25;
  struct AssemblyLoadHook * hook;

  if (func == 0B) goto <D.18746>; else goto <D.18747>;
  <D.18746>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1192, "func != NULL");
  return;
  <D.18747>:
  hook = monoeg_malloc0 (24);
  hook->func = func;
  hook->user_data = user_data;
  assembly_load_hook.25 = assembly_load_hook;
  hook->next = assembly_load_hook.25;
  assembly_load_hook = hook;
}


mono_assembly_invoke_search_hook (struct MonoAssemblyName * aname)
{
  struct MonoAssembly * D.18750;

  D.18750 = mono_assembly_invoke_search_hook_internal (aname, 0, 0);
  return D.18750;
}


mono_install_assembly_search_hook (struct MonoAssembly * (*MonoAssemblySearchFunc) (struct MonoAssemblyName *, void *) func, void * user_data)
{
  mono_install_assembly_search_hook_internal (func, user_data, 0, 0);
}


mono_install_assembly_search_hook_internal (struct MonoAssembly * (*MonoAssemblySearchFunc) (struct MonoAssemblyName *, void *) func, void * user_data, gboolean refonly, gboolean postload)
{
  struct AssemblySearchHook * assembly_search_hook.26;
  struct AssemblySearchHook * hook;

  if (func == 0B) goto <D.18752>; else goto <D.18753>;
  <D.18752>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1250, "func != NULL");
  return;
  <D.18753>:
  hook = monoeg_malloc0 (32);
  hook->func = func;
  hook->user_data = user_data;
  hook->refonly = refonly;
  hook->postload = postload;
  assembly_search_hook.26 = assembly_search_hook;
  hook->next = assembly_search_hook.26;
  assembly_search_hook = hook;
}


mono_install_assembly_refonly_search_hook (struct MonoAssembly * (*MonoAssemblySearchFunc) (struct MonoAssemblyName *, void *) func, void * user_data)
{
  mono_install_assembly_search_hook_internal (func, user_data, 1, 0);
}


mono_install_assembly_postload_search_hook (struct MonoAssembly * (*MonoAssemblySearchFunc) (struct MonoAssemblyName *, void *) func, void * user_data)
{
  mono_install_assembly_search_hook_internal (func, user_data, 0, 1);
}


mono_install_assembly_postload_refonly_search_hook (struct MonoAssembly * (*MonoAssemblySearchFunc) (struct MonoAssemblyName *, void *) func, void * user_data)
{
  mono_install_assembly_search_hook_internal (func, user_data, 1, 1);
}


mono_install_assembly_preload_hook (struct MonoAssembly * (*MonoAssemblyPreLoadFunc) (struct MonoAssemblyName *, char * *, void *) func, void * user_data)
{
  struct AssemblyPreLoadHook * assembly_preload_hook.27;
  struct AssemblyPreLoadHook * hook;

  if (func == 0B) goto <D.18756>; else goto <D.18757>;
  <D.18756>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1341, "func != NULL");
  return;
  <D.18757>:
  hook = monoeg_malloc0 (24);
  hook->func = func;
  hook->user_data = user_data;
  assembly_preload_hook.27 = assembly_preload_hook;
  hook->next = assembly_preload_hook.27;
  assembly_preload_hook = hook;
}


mono_install_assembly_refonly_preload_hook (struct MonoAssembly * (*MonoAssemblyPreLoadFunc) (struct MonoAssemblyName *, char * *, void *) func, void * user_data)
{
  struct AssemblyPreLoadHook * assembly_refonly_preload_hook.28;
  struct AssemblyPreLoadHook * hook;

  if (func == 0B) goto <D.18760>; else goto <D.18761>;
  <D.18760>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1355, "func != NULL");
  return;
  <D.18761>:
  hook = monoeg_malloc0 (24);
  hook->func = func;
  hook->user_data = user_data;
  assembly_refonly_preload_hook.28 = assembly_refonly_preload_hook;
  hook->next = assembly_refonly_preload_hook.28;
  assembly_refonly_preload_hook = hook;
}


__attribute__((visibility ("hidden")))
mono_assembly_open_from_bundle (const char * filename, MonoImageOpenStatus * status, gboolean refonly)
{
  const struct MonoBundledAssembly * * bundles.29;
  struct MonoImage * D.18767;
  _Bool D.18770;
  long int D.18771;
  long int D.18772;
  long unsigned int D.18775;
  long unsigned int D.18776;
  const struct MonoBundledAssembly * * D.18777;
  const struct MonoBundledAssembly * D.18778;
  const char * D.18779;
  int D.18780;
  const unsigned char * D.18783;
  unsigned int D.18784;
  _Bool D.18788;
  long int D.18789;
  long int D.18790;
  int i;
  char * name;
  struct MonoImage * image;

  image = 0B;
  bundles.29 = bundles;
  if (bundles.29 == 0B) goto <D.18765>; else goto <D.18766>;
  <D.18765>:
  D.18767 = 0B;
  return D.18767;
  <D.18766>:
  name = monoeg_g_path_get_basename (filename);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18768>; else goto <D.18769>;
    <D.18768>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18769>:
    D.18770 = ret != 0;
    D.18771 = (long int) D.18770;
    D.18772 = __builtin_expect (D.18771, 0);
    if (D.18772 != 0) goto <D.18773>; else goto <D.18774>;
    <D.18773>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1466, "ret == 0");
    <D.18774>:
  }
  i = 0;
  goto <D.17806>;
  <D.17805>:
  bundles.29 = bundles;
  D.18775 = (long unsigned int) i;
  D.18776 = D.18775 * 8;
  D.18777 = bundles.29 + D.18776;
  D.18778 = *D.18777;
  D.18779 = D.18778->name;
  D.18780 = strcmp (D.18779, name);
  if (D.18780 == 0) goto <D.18781>; else goto <D.18782>;
  <D.18781>:
  bundles.29 = bundles;
  D.18775 = (long unsigned int) i;
  D.18776 = D.18775 * 8;
  D.18777 = bundles.29 + D.18776;
  D.18778 = *D.18777;
  D.18783 = D.18778->data;
  bundles.29 = bundles;
  D.18775 = (long unsigned int) i;
  D.18776 = D.18775 * 8;
  D.18777 = bundles.29 + D.18776;
  D.18778 = *D.18777;
  D.18784 = D.18778->size;
  image = mono_image_open_from_data_with_name (D.18783, D.18784, 0, status, refonly, name);
  goto <D.17804>;
  <D.18782>:
  i = i + 1;
  <D.17806>:
  if (image == 0B) goto <D.18785>; else goto <D.17804>;
  <D.18785>:
  bundles.29 = bundles;
  D.18775 = (long unsigned int) i;
  D.18776 = D.18775 * 8;
  D.18777 = bundles.29 + D.18776;
  D.18778 = *D.18777;
  if (D.18778 != 0B) goto <D.17805>; else goto <D.17804>;
  <D.17804>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18786>; else goto <D.18787>;
    <D.18786>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18787>:
    D.18788 = ret != 0;
    D.18789 = (long int) D.18788;
    D.18790 = __builtin_expect (D.18789, 0);
    if (D.18790 != 0) goto <D.18791>; else goto <D.18792>;
    <D.18791>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1473, "ret == 0");
    <D.18792>:
  }
  monoeg_g_free (name);
  if (image != 0B) goto <D.18793>; else goto <D.18794>;
  <D.18793>:
  mono_image_addref (image);
  D.18767 = image;
  return D.18767;
  <D.18794>:
  D.18767 = 0B;
  return D.18767;
}


mono_assembly_open_full (const char * filename, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.18798;
  _Bool iftmp.30;
  long unsigned int D.18802;
  int D.18805;
  int D.18807;
  gchar * D.18810;
  char D.18811;
  struct GError * error.31;
  gchar * D.18819;
  unsigned char D.18821;
  const struct MonoBundledAssembly * * bundles.32;
  <unnamed type> D.18835;
  struct MonoAssembly * D.18838;
  struct MonoImage * D.18845;
  struct MonoImage * image;
  struct MonoAssembly * ass;
  MonoImageOpenStatus def_status;
  gchar * fname;
  gchar * new_fname;

  try
    {
      if (filename == 0B) goto <D.18796>; else goto <D.18797>;
      <D.18796>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1491, "filename != NULL");
      D.18798 = 0B;
      return D.18798;
      <D.18797>:
      if (status == 0B) goto <D.18799>; else goto <D.18800>;
      <D.18799>:
      status = &def_status;
      <D.18800>:
      *status = 0;
      D.18802 = __strlen_g ("file://");
      if (D.18802 <= 6) goto <D.18803>; else goto <D.18804>;
      <D.18803>:
      D.18805 = strcmp (filename, "file://");
      iftmp.30 = D.18805 == 0;
      goto <D.18806>;
      <D.18804>:
      D.18807 = strncmp (filename, "file://", 7);
      iftmp.30 = D.18807 == 0;
      <D.18806>:
      if (iftmp.30 != 0) goto <D.18808>; else goto <D.18809>;
      <D.18808>:
      {
        struct GError * error;
        gchar * uri;
        gchar * tmpuri;

        try
          {
            error = 0B;
            uri = filename;
            D.18810 = uri + 7;
            D.18811 = *D.18810;
            if (D.18811 != 47) goto <D.18812>; else goto <D.18813>;
            <D.18812>:
            D.18810 = uri + 7;
            uri = monoeg_g_strdup_printf ("file:///%s", D.18810);
            <D.18813>:
            tmpuri = uri;
            uri = mono_escape_uri_string (tmpuri);
            fname = monoeg_g_filename_from_uri (uri, 0B, &error);
            monoeg_g_free (uri);
            if (tmpuri != filename) goto <D.18814>; else goto <D.18815>;
            <D.18814>:
            monoeg_g_free (tmpuri);
            <D.18815>:
            error.31 = error;
            if (error.31 != 0B) goto <D.18817>; else goto <D.18818>;
            <D.18817>:
            error.31 = error;
            D.18819 = error.31->message;
            monoeg_g_log (0B, 16, "%s\n", D.18819);
            error.31 = error;
            monoeg_g_error_free (error.31);
            fname = monoeg_strdup (filename);
            <D.18818>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      goto <D.18820>;
      <D.18809>:
      fname = monoeg_strdup (filename);
      <D.18820>:
      mono_trace (64, 1, "Assembly Loader probing location: \'%s\'.", fname);
      new_fname = 0B;
      D.18821 = mono_assembly_is_in_gac (fname);
      if (D.18821 == 0) goto <D.18822>; else goto <D.18823>;
      <D.18822>:
      new_fname = mono_make_shadow_copy (fname);
      <D.18823>:
      if (new_fname != 0B) goto <D.18824>; else goto <D.18825>;
      <D.18824>:
      if (new_fname != fname) goto <D.18826>; else goto <D.18827>;
      <D.18826>:
      monoeg_g_free (fname);
      fname = new_fname;
      mono_trace (64, 1, "Assembly Loader shadow-copied assembly to: \'%s\'.", fname);
      <D.18827>:
      <D.18825>:
      image = 0B;
      bundles.32 = bundles;
      if (bundles.32 != 0B) goto <D.18829>; else goto <D.18830>;
      <D.18829>:
      image = mono_assembly_open_from_bundle (fname, status, refonly);
      <D.18830>:
      if (image == 0B) goto <D.18831>; else goto <D.18832>;
      <D.18831>:
      image = mono_image_open_full (fname, status, refonly);
      <D.18832>:
      if (image == 0B) goto <D.18833>; else goto <D.18834>;
      <D.18833>:
      D.18835 = *status;
      if (D.18835 == 0) goto <D.18836>; else goto <D.18837>;
      <D.18836>:
      *status = 1;
      <D.18837>:
      monoeg_g_free (fname);
      D.18798 = 0B;
      return D.18798;
      <D.18834>:
      D.18838 = image->assembly;
      if (D.18838 != 0B) goto <D.18839>; else goto <D.18840>;
      <D.18839>:
      D.18838 = image->assembly;
      mono_assembly_invoke_load_hook (D.18838);
      mono_image_close (image);
      monoeg_g_free (fname);
      D.18798 = image->assembly;
      return D.18798;
      <D.18840>:
      ass = mono_assembly_load_from_full (image, fname, status, refonly);
      if (ass != 0B) goto <D.18841>; else goto <D.18842>;
      <D.18841>:
      mono_trace (64, 1, "Assembly Loader loaded assembly from location: \'%s\'.", filename);
      if (refonly == 0) goto <D.18843>; else goto <D.18844>;
      <D.18843>:
      D.18845 = ass->image;
      mono_config_for_assembly (D.18845);
      <D.18844>:
      <D.18842>:
      mono_image_close (image);
      monoeg_g_free (fname);
      D.18798 = ass;
      return D.18798;
    }
  finally
    {
      def_status = {CLOBBER};
    }
}


mono_assembly_is_in_gac (const gchar * filename)
{
  MonoBoolean D.18850;
  gchar * D.18851;
  char * D.18852;
  long unsigned int D.18855;
  char D.18856;
  _Bool iftmp.33;
  long unsigned int D.18860;
  int D.18863;
  int D.18865;
  _Bool iftmp.34;
  long unsigned int D.18871;
  int D.18874;
  int D.18876;
  _Bool iftmp.35;
  long unsigned int D.18882;
  int D.18885;
  int D.18887;
  char * D.18893;
  long unsigned int D.18896;
  _Bool iftmp.36;
  long unsigned int D.18900;
  int D.18903;
  int D.18905;
  _Bool iftmp.37;
  long unsigned int D.18911;
  int D.18914;
  int D.18916;
  const gchar * rootdir;
  gchar * gp;
  gchar * * paths;

  if (filename == 0B) goto <D.18848>; else goto <D.18849>;
  <D.18848>:
  D.18850 = 0;
  return D.18850;
  <D.18849>:
  paths = extra_gac_paths;
  goto <D.18030>;
  <D.18029>:
  D.18851 = *paths;
  D.18852 = strstr (D.18851, filename);
  D.18851 = *paths;
  if (D.18852 != D.18851) goto <D.18853>; else goto <D.18854>;
  <D.18853>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18854>:
  D.18851 = *paths;
  D.18855 = __strlen_g (D.18851);
  gp = filename + D.18855;
  D.18856 = *gp;
  if (D.18856 != 47) goto <D.18857>; else goto <D.18858>;
  <D.18857>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18858>:
  gp = gp + 1;
  D.18860 = __strlen_g ("lib");
  if (D.18860 <= 2) goto <D.18861>; else goto <D.18862>;
  <D.18861>:
  D.18863 = strcmp (gp, "lib");
  iftmp.33 = D.18863 != 0;
  goto <D.18864>;
  <D.18862>:
  D.18865 = strncmp (gp, "lib", 3);
  iftmp.33 = D.18865 != 0;
  <D.18864>:
  if (iftmp.33 != 0) goto <D.18866>; else goto <D.18867>;
  <D.18866>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18867>:
  gp = gp + 3;
  D.18856 = *gp;
  if (D.18856 != 47) goto <D.18868>; else goto <D.18869>;
  <D.18868>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18869>:
  gp = gp + 1;
  D.18871 = __strlen_g ("mono");
  if (D.18871 <= 3) goto <D.18872>; else goto <D.18873>;
  <D.18872>:
  D.18874 = strcmp (gp, "mono");
  iftmp.34 = D.18874 != 0;
  goto <D.18875>;
  <D.18873>:
  D.18876 = strncmp (gp, "mono", 4);
  iftmp.34 = D.18876 != 0;
  <D.18875>:
  if (iftmp.34 != 0) goto <D.18877>; else goto <D.18878>;
  <D.18877>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18878>:
  gp = gp + 4;
  D.18856 = *gp;
  if (D.18856 != 47) goto <D.18879>; else goto <D.18880>;
  <D.18879>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18880>:
  gp = gp + 1;
  D.18882 = __strlen_g ("gac");
  if (D.18882 <= 2) goto <D.18883>; else goto <D.18884>;
  <D.18883>:
  D.18885 = strcmp (gp, "gac");
  iftmp.35 = D.18885 != 0;
  goto <D.18886>;
  <D.18884>:
  D.18887 = strncmp (gp, "gac", 3);
  iftmp.35 = D.18887 != 0;
  <D.18886>:
  if (iftmp.35 != 0) goto <D.18888>; else goto <D.18889>;
  <D.18888>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18889>:
  gp = gp + 3;
  D.18856 = *gp;
  if (D.18856 != 47) goto <D.18890>; else goto <D.18891>;
  <D.18890>:
  // predicted unlikely by continue predictor.
  goto <D.18028>;
  <D.18891>:
  D.18850 = 1;
  return D.18850;
  <D.18028>:
  paths = paths + 8;
  <D.18030>:
  if (paths != 0B) goto <D.18892>; else goto <D.18031>;
  <D.18892>:
  D.18851 = *paths;
  if (D.18851 != 0B) goto <D.18029>; else goto <D.18031>;
  <D.18031>:
  rootdir = mono_assembly_getrootdir ();
  D.18893 = strstr (filename, rootdir);
  if (D.18893 != filename) goto <D.18894>; else goto <D.18895>;
  <D.18894>:
  D.18850 = 0;
  return D.18850;
  <D.18895>:
  D.18896 = __strlen_g (rootdir);
  gp = filename + D.18896;
  D.18856 = *gp;
  if (D.18856 != 47) goto <D.18897>; else goto <D.18898>;
  <D.18897>:
  D.18850 = 0;
  return D.18850;
  <D.18898>:
  gp = gp + 1;
  D.18900 = __strlen_g ("mono");
  if (D.18900 <= 3) goto <D.18901>; else goto <D.18902>;
  <D.18901>:
  D.18903 = strcmp (gp, "mono");
  iftmp.36 = D.18903 != 0;
  goto <D.18904>;
  <D.18902>:
  D.18905 = strncmp (gp, "mono", 4);
  iftmp.36 = D.18905 != 0;
  <D.18904>:
  if (iftmp.36 != 0) goto <D.18906>; else goto <D.18907>;
  <D.18906>:
  D.18850 = 0;
  return D.18850;
  <D.18907>:
  gp = gp + 4;
  D.18856 = *gp;
  if (D.18856 != 47) goto <D.18908>; else goto <D.18909>;
  <D.18908>:
  D.18850 = 0;
  return D.18850;
  <D.18909>:
  gp = gp + 1;
  D.18911 = __strlen_g ("gac");
  if (D.18911 <= 2) goto <D.18912>; else goto <D.18913>;
  <D.18912>:
  D.18914 = strcmp (gp, "gac");
  iftmp.37 = D.18914 != 0;
  goto <D.18915>;
  <D.18913>:
  D.18916 = strncmp (gp, "gac", 3);
  iftmp.37 = D.18916 != 0;
  <D.18915>:
  if (iftmp.37 != 0) goto <D.18917>; else goto <D.18918>;
  <D.18917>:
  D.18850 = 0;
  return D.18850;
  <D.18918>:
  gp = gp + 3;
  D.18856 = *gp;
  if (D.18856 != 47) goto <D.18919>; else goto <D.18920>;
  <D.18919>:
  D.18850 = 0;
  return D.18850;
  <D.18920>:
  D.18850 = 1;
  return D.18850;
}


__attribute__((visibility ("hidden")))
mono_assembly_load_friends (struct MonoAssembly * ass)
{
  unsigned char D.18922;
  _Bool D.18929;
  long int D.18930;
  long int D.18931;
  _Bool D.18936;
  long int D.18937;
  long int D.18938;
  _Bool D.18943;
  long int D.18944;
  long int D.18945;
  _Bool D.18952;
  long int D.18953;
  long int D.18954;
  _Bool D.18959;
  long int D.18960;
  long int D.18961;
  struct MonoMethod * D.18966;
  struct MonoClass * D.18968;
  struct MonoClass * D.18969;
  unsigned int D.18970;
  const mono_byte * data.38;
  const gchar * data.39;
  char D.18977;
  const gchar * D.18979;
  char D.18980;
  const gchar * D.18982;
  char D.18983;
  int D.18984;
  int D.18988;
  _Bool D.18991;
  long int D.18992;
  long int D.18993;
  _Bool D.19000;
  long int D.19001;
  long int D.19002;
  _Bool D.19007;
  long int D.19008;
  long int D.19009;
  int i;
  struct MonoCustomAttrInfo * attrs;
  struct GSList * list;

  D.18922 = ass->friend_assembly_names_inited;
  if (D.18922 != 0) goto <D.18923>; else goto <D.18924>;
  <D.18923>:
  return;
  <D.18924>:
  attrs = mono_custom_attrs_from_assembly (ass);
  if (attrs == 0B) goto <D.18925>; else goto <D.18926>;
  <D.18925>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18927>; else goto <D.18928>;
    <D.18927>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18928>:
    D.18929 = ret != 0;
    D.18930 = (long int) D.18929;
    D.18931 = __builtin_expect (D.18930, 0);
    if (D.18931 != 0) goto <D.18932>; else goto <D.18933>;
    <D.18932>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1611, "ret == 0");
    <D.18933>:
  }
  ass->friend_assembly_names_inited = 1;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18934>; else goto <D.18935>;
    <D.18934>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18935>:
    D.18936 = ret != 0;
    D.18937 = (long int) D.18936;
    D.18938 = __builtin_expect (D.18937, 0);
    if (D.18938 != 0) goto <D.18939>; else goto <D.18940>;
    <D.18939>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1613, "ret == 0");
    <D.18940>:
  }
  return;
  <D.18926>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18941>; else goto <D.18942>;
    <D.18941>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18942>:
    D.18943 = ret != 0;
    D.18944 = (long int) D.18943;
    D.18945 = __builtin_expect (D.18944, 0);
    if (D.18945 != 0) goto <D.18946>; else goto <D.18947>;
    <D.18946>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1617, "ret == 0");
    <D.18947>:
  }
  D.18922 = ass->friend_assembly_names_inited;
  if (D.18922 != 0) goto <D.18948>; else goto <D.18949>;
  <D.18948>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18950>; else goto <D.18951>;
    <D.18950>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18951>:
    D.18952 = ret != 0;
    D.18953 = (long int) D.18952;
    D.18954 = __builtin_expect (D.18953, 0);
    if (D.18954 != 0) goto <D.18955>; else goto <D.18956>;
    <D.18955>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1619, "ret == 0");
    <D.18956>:
  }
  return;
  <D.18949>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18957>; else goto <D.18958>;
    <D.18957>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18958>:
    D.18959 = ret != 0;
    D.18960 = (long int) D.18959;
    D.18961 = __builtin_expect (D.18960, 0);
    if (D.18961 != 0) goto <D.18962>; else goto <D.18963>;
    <D.18962>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1622, "ret == 0");
    <D.18963>:
  }
  list = 0B;
  i = 0;
  goto <D.17842>;
  <D.17841>:
  {
    struct MonoCustomAttrEntry * attr;
    struct MonoAssemblyName * aname;
    const gchar * data;
    guint slen;

    try
      {
        attr = &attrs->attrs[i];
        D.18966 = attr->ctor;
        if (D.18966 == 0B) goto <D.18964>; else goto <D.18967>;
        <D.18967>:
        D.18966 = attr->ctor;
        D.18968 = D.18966->klass;
        D.18969 = mono_defaults.internals_visible_class;
        if (D.18968 != D.18969) goto <D.18964>; else goto <D.18965>;
        <D.18964>:
        // predicted unlikely by continue predictor.
        goto <D.17840>;
        <D.18965>:
        D.18970 = attr->data_size;
        if (D.18970 <= 3) goto <D.18971>; else goto <D.18972>;
        <D.18971>:
        // predicted unlikely by continue predictor.
        goto <D.17840>;
        <D.18972>:
        data.38 = attr->data;
        data = data.38;
        data.39 = data;
        D.18977 = *data.39;
        if (D.18977 != 1) goto <D.18974>; else goto <D.18978>;
        <D.18978>:
        data.39 = data;
        D.18979 = data.39 + 1;
        D.18980 = *D.18979;
        if (D.18980 != 0) goto <D.18974>; else goto <D.18981>;
        <D.18981>:
        data.39 = data;
        D.18982 = data.39 + 2;
        D.18983 = *D.18982;
        if (D.18983 == 255) goto <D.18974>; else goto <D.18975>;
        <D.18974>:
        // predicted unlikely by continue predictor.
        goto <D.17840>;
        <D.18975>:
        data.39 = data;
        D.18982 = data.39 + 2;
        slen = mono_metadata_decode_value (D.18982, &data);
        aname = monoeg_malloc0 (80);
        data.39 = data;
        D.18984 = mono_assembly_name_parse_full (data.39, aname, 1, 0B, 0B);
        if (D.18984 != 0) goto <D.18985>; else goto <D.18986>;
        <D.18985>:
        list = monoeg_g_slist_prepend (list, aname);
        goto <D.18987>;
        <D.18986>:
        monoeg_g_free (aname);
        <D.18987>:
      }
    finally
      {
        data = {CLOBBER};
      }
  }
  <D.17840>:
  i = i + 1;
  <D.17842>:
  D.18988 = attrs->num_attrs;
  if (D.18988 > i) goto <D.17841>; else goto <D.17843>;
  <D.17843>:
  mono_custom_attrs_free (attrs);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18989>; else goto <D.18990>;
    <D.18989>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18990>:
    D.18991 = ret != 0;
    D.18992 = (long int) D.18991;
    D.18993 = __builtin_expect (D.18992, 0);
    if (D.18993 != 0) goto <D.18994>; else goto <D.18995>;
    <D.18994>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1654, "ret == 0");
    <D.18995>:
  }
  D.18922 = ass->friend_assembly_names_inited;
  if (D.18922 != 0) goto <D.18996>; else goto <D.18997>;
  <D.18996>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18998>; else goto <D.18999>;
    <D.18998>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18999>:
    D.19000 = ret != 0;
    D.19001 = (long int) D.19000;
    D.19002 = __builtin_expect (D.19001, 0);
    if (D.19002 != 0) goto <D.19003>; else goto <D.19004>;
    <D.19003>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1656, "ret == 0");
    <D.19004>:
  }
  monoeg_g_slist_foreach (list, free_item, 0B);
  monoeg_g_slist_free (list);
  return;
  <D.18997>:
  ass->friend_assembly_names = list;
  mono_memory_barrier ();
  ass->friend_assembly_names_inited = 1;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19005>; else goto <D.19006>;
    <D.19005>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19006>:
    D.19007 = ret != 0;
    D.19008 = (long int) D.19007;
    D.19009 = __builtin_expect (D.19008, 0);
    if (D.19009 != 0) goto <D.19010>; else goto <D.19011>;
    <D.19010>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1666, "ret == 0");
    <D.19011>:
  }
}


free_item (void * val, void * user_data)
{
  monoeg_g_free (val);
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_assembly_open (const char * filename, MonoImageOpenStatus * status)
{
  struct MonoAssembly * D.19015;

  D.19015 = mono_assembly_open_full (filename, status, 0);
  return D.19015;
}


mono_assembly_load_from_full (struct MonoImage * image, const char * fname, MonoImageOpenStatus * status, gboolean refonly)
{
  long unsigned int D.19017;
  long unsigned int D.19018;
  struct MonoAssembly * D.19021;
  struct MonoAssemblyName * D.19022;
  struct MonoImage * D.19023;
  const char * D.19026;
  int D.19027;
  char * D.19030;
  int D.19031;
  _Bool D.19038;
  long int D.19039;
  long int D.19040;
  struct MonoAssembly * D.19043;
  _Bool D.19048;
  long int D.19049;
  long int D.19050;
  struct GList * loaded_assemblies.40;
  struct GList * D.19054;
  _Bool D.19057;
  long int D.19058;
  long int D.19059;
  struct MonoAssembly * ass;
  struct MonoAssembly * ass2;
  char * base_dir;

  D.19017 = BIT_FIELD_REF <*image, 64, 5696>;
  D.19018 = D.19017 & 18446742974197923840;
  if (D.19018 == 0) goto <D.19019>; else goto <D.19020>;
  <D.19019>:
  *status = 3;
  D.19021 = 0B;
  return D.19021;
  <D.19020>:
  base_dir = absolute_dir (fname);
  ass = monoeg_malloc0 (128);
  ass->basedir = base_dir;
  ass->ref_only = refonly;
  ass->image = image;
  mono_profiler_assembly_event (ass, 0);
  D.19022 = &ass->aname;
  mono_assembly_fill_assembly_name (image, D.19022);
  D.19023 = mono_defaults.corlib;
  if (D.19023 != 0B) goto <D.19024>; else goto <D.19025>;
  <D.19024>:
  D.19026 = ass->aname.name;
  D.19027 = strcmp (D.19026, "mscorlib");
  if (D.19027 == 0) goto <D.19028>; else goto <D.19029>;
  <D.19028>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  D.19023 = mono_defaults.corlib;
  mono_image_addref (D.19023);
  *status = 0;
  D.19023 = mono_defaults.corlib;
  D.19021 = D.19023->assembly;
  return D.19021;
  <D.19029>:
  <D.19025>:
  mono_image_addref (image);
  D.19026 = ass->aname.name;
  D.19030 = image->name;
  D.19031 = image->ref_count;
  mono_trace (64, 1, "Image addref %s[%p] -> %s[%p]: %d", D.19026, ass, D.19030, image, D.19031);
  D.19026 = ass->aname.name;
  if (D.19026 != 0B) goto <D.19032>; else goto <D.19033>;
  <D.19032>:
  D.19022 = &ass->aname;
  ass2 = mono_assembly_invoke_search_hook_internal (D.19022, refonly, 0);
  if (ass2 != 0B) goto <D.19034>; else goto <D.19035>;
  <D.19034>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.19021 = ass2;
  return D.19021;
  <D.19035>:
  <D.19033>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19036>; else goto <D.19037>;
    <D.19036>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19037>:
    D.19038 = ret != 0;
    D.19039 = (long int) D.19038;
    D.19040 = __builtin_expect (D.19039, 0);
    if (D.19040 != 0) goto <D.19041>; else goto <D.19042>;
    <D.19041>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1759, "ret == 0");
    <D.19042>:
  }
  D.19043 = image->assembly;
  if (D.19043 != 0B) goto <D.19044>; else goto <D.19045>;
  <D.19044>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19046>; else goto <D.19047>;
    <D.19046>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19047>:
    D.19048 = ret != 0;
    D.19049 = (long int) D.19048;
    D.19050 = __builtin_expect (D.19049, 0);
    if (D.19050 != 0) goto <D.19051>; else goto <D.19052>;
    <D.19051>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1766, "ret == 0");
    <D.19052>:
  }
  ass2 = image->assembly;
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.19021 = ass2;
  return D.19021;
  <D.19045>:
  image->assembly = ass;
  loaded_assemblies.40 = loaded_assemblies;
  D.19054 = monoeg_g_list_prepend (loaded_assemblies.40, ass);
  loaded_assemblies = D.19054;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19055>; else goto <D.19056>;
    <D.19055>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19056>:
    D.19057 = ret != 0;
    D.19058 = (long int) D.19057;
    D.19059 = __builtin_expect (D.19058, 0);
    if (D.19059 != 0) goto <D.19060>; else goto <D.19061>;
    <D.19060>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1778, "ret == 0");
    <D.19061>:
  }
  mono_assembly_invoke_load_hook (ass);
  mono_profiler_assembly_loaded (ass, 0);
  D.19021 = ass;
  return D.19021;
}


absolute_dir (const gchar * filename)
{
  int D.19063;
  gchar * D.19066;
  int D.19067;
  int D.19070;
  struct GList * D.19075;
  long unsigned int D.19079;
  long unsigned int D.19080;
  gchar * * D.19081;
  void * D.19082;
  struct GList * D.19086;
  char D.19087;
  gchar * cwd;
  gchar * mixed;
  gchar * * parts;
  gchar * part;
  struct GList * list;
  struct GList * tmp;
  struct GString * result;
  gchar * res;
  gint i;

  D.19063 = monoeg_g_path_is_absolute (filename);
  if (D.19063 != 0) goto <D.19064>; else goto <D.19065>;
  <D.19064>:
  part = monoeg_g_path_get_dirname (filename);
  res = monoeg_g_strconcat (part, "/", 0B);
  monoeg_g_free (part);
  D.19066 = res;
  return D.19066;
  <D.19065>:
  cwd = monoeg_g_get_current_dir ();
  mixed = monoeg_g_build_path ("/", cwd, filename, 0B);
  parts = monoeg_g_strsplit (mixed, "/", 0);
  monoeg_g_free (mixed);
  monoeg_g_free (cwd);
  list = 0B;
  i = 0;
  goto <D.17790>;
  <D.17789>:
  D.19067 = strcmp (part, ".");
  if (D.19067 == 0) goto <D.19068>; else goto <D.19069>;
  <D.19068>:
  // predicted unlikely by continue predictor.
  goto <D.17788>;
  <D.19069>:
  D.19070 = strcmp (part, "..");
  if (D.19070 == 0) goto <D.19071>; else goto <D.19072>;
  <D.19071>:
  if (list != 0B) goto <D.19073>; else goto <D.19074>;
  <D.19073>:
  D.19075 = list->next;
  if (D.19075 != 0B) goto <D.19076>; else goto <D.19077>;
  <D.19076>:
  list = monoeg_g_list_delete_link (list, list);
  <D.19077>:
  <D.19074>:
  goto <D.19078>;
  <D.19072>:
  list = monoeg_g_list_prepend (list, part);
  <D.19078>:
  <D.17788>:
  i = i + 1;
  <D.17790>:
  D.19079 = (long unsigned int) i;
  D.19080 = D.19079 * 8;
  D.19081 = parts + D.19080;
  part = *D.19081;
  if (part != 0B) goto <D.17789>; else goto <D.17791>;
  <D.17791>:
  result = monoeg_g_string_new ("");
  list = monoeg_g_list_reverse (list);
  tmp = list;
  goto <D.17793>;
  <D.17792>:
  D.19082 = tmp->data;
  if (D.19082 != 0B) goto <D.19083>; else goto <D.19084>;
  <D.19083>:
  D.19082 = tmp->data;
  monoeg_g_string_append_printf (result, "%s%c", D.19082, 47);
  <D.19084>:
  tmp = tmp->next;
  <D.17793>:
  if (tmp != 0B) goto <D.19085>; else goto <D.17794>;
  <D.19085>:
  D.19086 = tmp->next;
  if (D.19086 != 0B) goto <D.17792>; else goto <D.17794>;
  <D.17794>:
  res = result->str;
  monoeg_g_string_free (result, 0);
  monoeg_g_list_free (list);
  monoeg_g_strfreev (parts);
  D.19087 = *res;
  if (D.19087 == 0) goto <D.19088>; else goto <D.19089>;
  <D.19088>:
  monoeg_g_free (res);
  D.19066 = monoeg_strdup (".");
  return D.19066;
  <D.19089>:
  D.19066 = res;
  return D.19066;
}


mono_assembly_load_from (struct MonoImage * image, const char * fname, MonoImageOpenStatus * status)
{
  struct MonoAssembly * D.19091;

  D.19091 = mono_assembly_load_from_full (image, fname, status, 0);
  return D.19091;
}


mono_assembly_name_free (struct MonoAssemblyName * aname)
{
  const char * D.19095;
  const char * D.19096;
  const char * D.19097;

  if (aname == 0B) goto <D.19093>; else goto <D.19094>;
  <D.19093>:
  return;
  <D.19094>:
  D.19095 = aname->name;
  monoeg_g_free (D.19095);
  D.19096 = aname->culture;
  monoeg_g_free (D.19096);
  D.19097 = aname->hash_value;
  monoeg_g_free (D.19097);
}


__attribute__((visibility ("hidden")))
mono_assembly_name_parse_full (const char * name, struct MonoAssemblyName * aname, gboolean save_public_key, gboolean * is_version_defined, gboolean * is_token_defined)
{
  gchar * D.19106;
  gboolean D.19107;
  gchar * D.19108;
  gchar * D.19109;
  gchar * D.19110;
  int D.19111;
  unsigned int part_name_len.41;
  gchar * part_name.42;
  long unsigned int D.19117;
  int D.19118;
  long unsigned int D.19121;
  int D.19125;
  long unsigned int D.19128;
  int D.19132;
  long unsigned int D.19135;
  int D.19139;
  long unsigned int D.19142;
  int D.19146;
  long unsigned int D.19149;
  int D.19151;
  int D.19155;
  int D.19159;
  gchar * value.43;
  int D.19163;
  int D.19167;
  int D.19171;
  int D.19175;
  int D.19179;
  gchar * dllname;
  gchar * version;
  gchar * culture;
  gchar * token;
  gchar * key;
  gchar * retargetable;
  gboolean res;
  gchar * value;
  gchar * part_name;
  guint32 part_name_len;
  gchar * * parts;
  gchar * * tmp;
  gboolean version_defined;
  gboolean token_defined;
  guint32 flags;
  guint32 arch;
  void cleanup_and_fail = <<< error >>>;

  try
    {
      version = 0B;
      culture = 0B;
      token = 0B;
      key = 0B;
      retargetable = 0B;
      flags = 0;
      arch = 0;
      if (is_version_defined == 0B) goto <D.19099>; else goto <D.19100>;
      <D.19099>:
      is_version_defined = &version_defined;
      <D.19100>:
      *is_version_defined = 0;
      if (is_token_defined == 0B) goto <D.19101>; else goto <D.19102>;
      <D.19101>:
      is_token_defined = &token_defined;
      <D.19102>:
      *is_token_defined = 0;
      tmp = monoeg_g_strsplit (name, ",", 6);
      parts = tmp;
      if (tmp == 0B) goto <D.19103>; else goto <D.19105>;
      <D.19105>:
      D.19106 = *tmp;
      if (D.19106 == 0B) goto <D.19103>; else goto <D.19104>;
      <D.19103>:
      monoeg_g_strfreev (tmp);
      D.19107 = 0;
      return D.19107;
      <D.19104>:
      D.19106 = *tmp;
      D.19108 = monoeg_g_strchomp (D.19106);
      dllname = monoeg_g_strchug (D.19108);
      tmp = tmp + 8;
      goto <D.17960>;
      <D.17961>:
      D.19106 = *tmp;
      D.19109 = monoeg_g_strchomp (D.19106);
      D.19110 = monoeg_g_strchug (D.19109);
      D.19111 = split_key_value (D.19110, &part_name, &part_name_len, &value);
      if (D.19111 == 0) goto cleanup_and_fail; else goto <D.19112>;
      <D.19112>:
      part_name_len.41 = part_name_len;
      if (part_name_len.41 == 7) goto <D.19114>; else goto <D.19115>;
      <D.19114>:
      part_name.42 = part_name;
      part_name_len.41 = part_name_len;
      D.19117 = (long unsigned int) part_name_len.41;
      D.19118 = monoeg_g_ascii_strncasecmp (part_name.42, "Version", D.19117);
      if (D.19118 == 0) goto <D.19119>; else goto <D.19120>;
      <D.19119>:
      *is_version_defined = 1;
      version = value;
      D.19121 = __strlen_g (version);
      if (D.19121 == 0) goto cleanup_and_fail; else goto <D.19122>;
      <D.19122>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.17960>;
      <D.19120>:
      <D.19115>:
      part_name_len.41 = part_name_len;
      if (part_name_len.41 == 7) goto <D.19123>; else goto <D.19124>;
      <D.19123>:
      part_name.42 = part_name;
      part_name_len.41 = part_name_len;
      D.19117 = (long unsigned int) part_name_len.41;
      D.19125 = monoeg_g_ascii_strncasecmp (part_name.42, "Culture", D.19117);
      if (D.19125 == 0) goto <D.19126>; else goto <D.19127>;
      <D.19126>:
      culture = value;
      D.19128 = __strlen_g (culture);
      if (D.19128 == 0) goto cleanup_and_fail; else goto <D.19129>;
      <D.19129>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.17960>;
      <D.19127>:
      <D.19124>:
      part_name_len.41 = part_name_len;
      if (part_name_len.41 == 14) goto <D.19130>; else goto <D.19131>;
      <D.19130>:
      part_name.42 = part_name;
      part_name_len.41 = part_name_len;
      D.19117 = (long unsigned int) part_name_len.41;
      D.19132 = monoeg_g_ascii_strncasecmp (part_name.42, "PublicKeyToken", D.19117);
      if (D.19132 == 0) goto <D.19133>; else goto <D.19134>;
      <D.19133>:
      *is_token_defined = 1;
      token = value;
      D.19135 = __strlen_g (token);
      if (D.19135 == 0) goto cleanup_and_fail; else goto <D.19136>;
      <D.19136>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.17960>;
      <D.19134>:
      <D.19131>:
      part_name_len.41 = part_name_len;
      if (part_name_len.41 == 9) goto <D.19137>; else goto <D.19138>;
      <D.19137>:
      part_name.42 = part_name;
      part_name_len.41 = part_name_len;
      D.19117 = (long unsigned int) part_name_len.41;
      D.19139 = monoeg_g_ascii_strncasecmp (part_name.42, "PublicKey", D.19117);
      if (D.19139 == 0) goto <D.19140>; else goto <D.19141>;
      <D.19140>:
      key = value;
      D.19142 = __strlen_g (key);
      if (D.19142 == 0) goto cleanup_and_fail; else goto <D.19143>;
      <D.19143>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.17960>;
      <D.19141>:
      <D.19138>:
      part_name_len.41 = part_name_len;
      if (part_name_len.41 == 12) goto <D.19144>; else goto <D.19145>;
      <D.19144>:
      part_name.42 = part_name;
      part_name_len.41 = part_name_len;
      D.19117 = (long unsigned int) part_name_len.41;
      D.19146 = monoeg_g_ascii_strncasecmp (part_name.42, "Retargetable", D.19117);
      if (D.19146 == 0) goto <D.19147>; else goto <D.19148>;
      <D.19147>:
      retargetable = value;
      D.19149 = __strlen_g (retargetable);
      if (D.19149 == 0) goto cleanup_and_fail; else goto <D.19150>;
      <D.19150>:
      D.19151 = monoeg_ascii_strcasecmp (retargetable, "yes");
      if (D.19151 == 0) goto <D.19152>; else goto <D.19153>;
      <D.19152>:
      flags = flags | 256;
      goto <D.19154>;
      <D.19153>:
      D.19155 = monoeg_ascii_strcasecmp (retargetable, "no");
      if (D.19155 != 0) goto cleanup_and_fail; else goto <D.19156>;
      <D.19156>:
      <D.19154>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.17960>;
      <D.19148>:
      <D.19145>:
      part_name_len.41 = part_name_len;
      if (part_name_len.41 == 21) goto <D.19157>; else goto <D.19158>;
      <D.19157>:
      part_name.42 = part_name;
      part_name_len.41 = part_name_len;
      D.19117 = (long unsigned int) part_name_len.41;
      D.19159 = monoeg_g_ascii_strncasecmp (part_name.42, "ProcessorArchitecture", D.19117);
      if (D.19159 == 0) goto <D.19160>; else goto <D.19161>;
      <D.19160>:
      value.43 = value;
      D.19163 = monoeg_ascii_strcasecmp (value.43, "None");
      if (D.19163 == 0) goto <D.19164>; else goto <D.19165>;
      <D.19164>:
      arch = 0;
      goto <D.19166>;
      <D.19165>:
      value.43 = value;
      D.19167 = monoeg_ascii_strcasecmp (value.43, "MSIL");
      if (D.19167 == 0) goto <D.19168>; else goto <D.19169>;
      <D.19168>:
      arch = 1;
      goto <D.19170>;
      <D.19169>:
      value.43 = value;
      D.19171 = monoeg_ascii_strcasecmp (value.43, "X86");
      if (D.19171 == 0) goto <D.19172>; else goto <D.19173>;
      <D.19172>:
      arch = 2;
      goto <D.19174>;
      <D.19173>:
      value.43 = value;
      D.19175 = monoeg_ascii_strcasecmp (value.43, "IA64");
      if (D.19175 == 0) goto <D.19176>; else goto <D.19177>;
      <D.19176>:
      arch = 3;
      goto <D.19178>;
      <D.19177>:
      value.43 = value;
      D.19179 = monoeg_ascii_strcasecmp (value.43, "AMD64");
      if (D.19179 == 0) goto <D.19180>; else goto cleanup_and_fail;
      <D.19180>:
      arch = 4;
      <D.19178>:
      <D.19174>:
      <D.19170>:
      <D.19166>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.17960>;
      <D.19161>:
      <D.19158>:
      monoeg_g_strfreev (parts);
      D.19107 = 0;
      return D.19107;
      <D.17960>:
      D.19106 = *tmp;
      if (D.19106 != 0B) goto <D.17961>; else goto <D.17962>;
      <D.17962>:
      if (retargetable != 0B) goto <D.19182>; else goto <D.19183>;
      <D.19182>:
      if (version == 0B) goto cleanup_and_fail; else goto <D.19184>;
      <D.19184>:
      if (culture == 0B) goto cleanup_and_fail; else goto <D.19185>;
      <D.19185>:
      if (key == 0B) goto <D.19186>; else goto <D.19181>;
      <D.19186>:
      if (token == 0B) goto cleanup_and_fail; else goto <D.19181>;
      <D.19181>:
      <D.19183>:
      res = build_assembly_name (dllname, version, culture, token, key, flags, arch, aname, save_public_key);
      monoeg_g_strfreev (parts);
      D.19107 = res;
      return D.19107;
      cleanup_and_fail:
      monoeg_g_strfreev (parts);
      D.19107 = 0;
      return D.19107;
    }
  finally
    {
      value = {CLOBBER};
      part_name = {CLOBBER};
      part_name_len = {CLOBBER};
      version_defined = {CLOBBER};
      token_defined = {CLOBBER};
    }
}


split_key_value (const gchar * pair, gchar * * key, guint32 * keylen, gchar * * value)
{
  gboolean D.19191;
  long int eqsign.44;
  gchar * D.19193;
  long int D.19194;
  long int D.19195;
  unsigned int D.19196;
  unsigned int D.19197;
  unsigned int D.19198;
  const short unsigned int * * D.19200;
  const short unsigned int * D.19201;
  sizetype D.19202;
  gchar * D.19203;
  char D.19204;
  long unsigned int D.19205;
  long unsigned int D.19206;
  const short unsigned int * D.19207;
  short unsigned int D.19208;
  int D.19209;
  int D.19210;
  char * D.19211;
  gchar * D.19212;
  gchar * D.19213;
  char * eqsign;

  eqsign = __builtin_strchr (pair, 61);
  if (eqsign == 0B) goto <D.19189>; else goto <D.19190>;
  <D.19189>:
  *key = 0B;
  *keylen = 0;
  *value = 0B;
  D.19191 = 0;
  return D.19191;
  <D.19190>:
  *key = pair;
  eqsign.44 = (long int) eqsign;
  D.19193 = *key;
  D.19194 = (long int) D.19193;
  D.19195 = eqsign.44 - D.19194;
  D.19196 = (unsigned int) D.19195;
  *keylen = D.19196;
  goto <D.17934>;
  <D.17933>:
  D.19197 = *keylen;
  D.19198 = D.19197 + 4294967295;
  *keylen = D.19198;
  <D.17934>:
  D.19197 = *keylen;
  if (D.19197 != 0) goto <D.19199>; else goto <D.17935>;
  <D.19199>:
  D.19200 = __ctype_b_loc ();
  D.19201 = *D.19200;
  D.19193 = *key;
  D.19197 = *keylen;
  D.19198 = D.19197 + 4294967295;
  D.19202 = (sizetype) D.19198;
  D.19203 = D.19193 + D.19202;
  D.19204 = *D.19203;
  D.19205 = (long unsigned int) D.19204;
  D.19206 = D.19205 * 2;
  D.19207 = D.19201 + D.19206;
  D.19208 = *D.19207;
  D.19209 = (int) D.19208;
  D.19210 = D.19209 & 32;
  if (D.19210 != 0) goto <D.17933>; else goto <D.17935>;
  <D.17935>:
  D.19211 = eqsign + 1;
  D.19212 = monoeg_g_strchomp (D.19211);
  D.19213 = monoeg_g_strchug (D.19212);
  *value = D.19213;
  D.19191 = 1;
  return D.19191;
}


build_assembly_name (const char * name, const char * version, const char * culture, const char * token, const char * key, guint32 flags, guint32 arch, struct MonoAssemblyName * aname, gboolean save_public_key)
{
  unsigned int version_parts.45;
  unsigned int D.19218;
  gboolean D.19221;
  int major.46;
  short unsigned int D.19223;
  int minor.47;
  short unsigned int D.19225;
  int build.48;
  short unsigned int D.19229;
  int revision.49;
  short unsigned int D.19234;
  short unsigned int D.19236;
  gchar * D.19237;
  int D.19240;
  gchar * D.19243;
  gchar * D.19245;
  _Bool iftmp.50;
  long unsigned int D.19249;
  int D.19252;
  int D.19254;
  long unsigned int D.19257;
  mono_byte[17] * D.19260;
  int D.19265;
  int D.19267;
  int is_ecma.51;
  gchar * pkey.52;
  unsigned int D.19275;
  gchar * pkeyptr.53;
  unsigned int len.54;
  gint major;
  gint minor;
  gint build;
  gint revision;
  gint len;
  gint version_parts;
  gchar * pkey;
  gchar * pkeyptr;
  gchar * encoded;
  gchar tok[8];

  try
    {
      memset (aname, 0, 80);
      if (version != 0B) goto <D.19215>; else goto <D.19216>;
      <D.19215>:
      version_parts = sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision);
      version_parts.45 = (unsigned int) version_parts;
      D.19218 = version_parts.45 + 4294967294;
      if (D.19218 > 2) goto <D.19219>; else goto <D.19220>;
      <D.19219>:
      D.19221 = 0;
      return D.19221;
      <D.19220>:
      major.46 = major;
      D.19223 = (short unsigned int) major.46;
      aname->major = D.19223;
      minor.47 = minor;
      D.19225 = (short unsigned int) minor.47;
      aname->minor = D.19225;
      if (version_parts > 2) goto <D.19226>; else goto <D.19227>;
      <D.19226>:
      build.48 = build;
      D.19229 = (short unsigned int) build.48;
      aname->build = D.19229;
      goto <D.19230>;
      <D.19227>:
      aname->build = 0;
      <D.19230>:
      if (version_parts == 4) goto <D.19231>; else goto <D.19232>;
      <D.19231>:
      revision.49 = revision;
      D.19234 = (short unsigned int) revision.49;
      aname->revision = D.19234;
      goto <D.19235>;
      <D.19232>:
      aname->revision = 0;
      <D.19235>:
      <D.19216>:
      aname->flags = flags;
      D.19236 = (short unsigned int) arch;
      aname->arch = D.19236;
      D.19237 = monoeg_strdup (name);
      aname->name = D.19237;
      if (culture != 0B) goto <D.19238>; else goto <D.19239>;
      <D.19238>:
      D.19240 = monoeg_ascii_strcasecmp (culture, "neutral");
      if (D.19240 == 0) goto <D.19241>; else goto <D.19242>;
      <D.19241>:
      D.19243 = monoeg_strdup ("");
      aname->culture = D.19243;
      goto <D.19244>;
      <D.19242>:
      D.19245 = monoeg_strdup (culture);
      aname->culture = D.19245;
      <D.19244>:
      <D.19239>:
      if (token != 0B) goto <D.19246>; else goto <D.19247>;
      <D.19246>:
      D.19249 = __strlen_g ("null");
      if (D.19249 <= 3) goto <D.19250>; else goto <D.19251>;
      <D.19250>:
      D.19252 = strcmp (token, "null");
      iftmp.50 = D.19252 != 0;
      goto <D.19253>;
      <D.19251>:
      D.19254 = strncmp (token, "null", 4);
      iftmp.50 = D.19254 != 0;
      <D.19253>:
      if (iftmp.50 != 0) goto <D.19255>; else goto <D.19256>;
      <D.19255>:
      {
        char * lower;

        D.19257 = __strlen_g (token);
        if (D.19257 != 16) goto <D.19258>; else goto <D.19259>;
        <D.19258>:
        mono_assembly_name_free (aname);
        D.19221 = 0;
        return D.19221;
        <D.19259>:
        lower = monoeg_g_ascii_strdown (token, 17);
        D.19260 = &aname->public_key_token;
        monoeg_g_strlcpy (D.19260, lower, 17);
        monoeg_g_free (lower);
      }
      <D.19256>:
      <D.19247>:
      if (key != 0B) goto <D.19261>; else goto <D.19262>;
      <D.19261>:
      {
        gboolean is_ecma;

        try
          {
            D.19265 = strcmp (key, "null");
            if (D.19265 == 0) goto <D.19263>; else goto <D.19266>;
            <D.19266>:
            D.19267 = parse_public_key (key, &pkey, &is_ecma);
            if (D.19267 == 0) goto <D.19263>; else goto <D.19264>;
            <D.19263>:
            mono_assembly_name_free (aname);
            D.19221 = 0;
            return D.19221;
            <D.19264>:
            is_ecma.51 = is_ecma;
            if (is_ecma.51 != 0) goto <D.19269>; else goto <D.19270>;
            <D.19269>:
            if (save_public_key != 0) goto <D.19271>; else goto <D.19272>;
            <D.19271>:
            pkey.52 = pkey;
            aname->public_key = pkey.52;
            goto <D.19274>;
            <D.19272>:
            pkey.52 = pkey;
            monoeg_g_free (pkey.52);
            <D.19274>:
            D.19260 = &aname->public_key_token;
            monoeg_g_strlcpy (D.19260, "b77a5c561934e089", 17);
            D.19221 = 1;
            return D.19221;
            <D.19270>:
            pkey.52 = pkey;
            D.19275 = mono_metadata_decode_blob_size (pkey.52, &pkeyptr);
            len = (gint) D.19275;
            pkeyptr.53 = pkeyptr;
            len.54 = (unsigned int) len;
            mono_digest_get_public_token (&tok, pkeyptr.53, len.54);
            encoded = encode_public_tok (&tok, 8);
            D.19260 = &aname->public_key_token;
            monoeg_g_strlcpy (D.19260, encoded, 17);
            monoeg_g_free (encoded);
            if (save_public_key != 0) goto <D.19278>; else goto <D.19279>;
            <D.19278>:
            pkey.52 = pkey;
            aname->public_key = pkey.52;
            goto <D.19280>;
            <D.19279>:
            pkey.52 = pkey;
            monoeg_g_free (pkey.52);
            <D.19280>:
          }
        finally
          {
            is_ecma = {CLOBBER};
          }
      }
      <D.19262>:
      D.19221 = 1;
      return D.19221;
    }
  finally
    {
      major = {CLOBBER};
      minor = {CLOBBER};
      build = {CLOBBER};
      revision = {CLOBBER};
      pkey = {CLOBBER};
      pkeyptr = {CLOBBER};
      tok = {CLOBBER};
    }
}


parse_public_key (const gchar * key, gchar * * pubkey, gboolean * is_ecma)
{
  long unsigned int D.19285;
  long unsigned int D.19286;
  gboolean D.19289;
  int D.19290;
  gchar * D.19295;
  char D.19296;
  int D.19297;
  char D.19298;
  const gchar * D.19299;
  char D.19300;
  int D.19301;
  signed char D.19302;
  signed char val.55;
  signed char D.19304;
  int D.19305;
  const gchar * D.19308;
  char D.19309;
  int D.19310;
  const gchar * D.19311;
  char D.19312;
  int D.19313;
  signed char D.19314;
  signed char D.19315;
  long unsigned int D.19318;
  long unsigned int D.19319;
  int j.56;
  sizetype D.19323;
  const gchar * D.19324;
  char D.19325;
  int D.19326;
  char D.19327;
  char D.19328;
  int j.57;
  sizetype D.19330;
  const gchar * D.19331;
  char D.19332;
  int D.19333;
  char D.19334;
  signed char D.19335;
  signed char D.19336;
  signed char D.19337;
  char D.19338;
  char D.19341;
  char D.19343;
  char D.19345;
  char D.19347;
  const guint32 * D.19349;
  unsigned int D.19350;
  unsigned int D.19351;
  unsigned int D.19352;
  unsigned int D.19353;
  unsigned int D.19354;
  unsigned int D.19355;
  unsigned int D.19356;
  unsigned int D.19357;
  unsigned int D.19358;
  unsigned int D.19359;
  const guint32 * D.19360;
  unsigned int D.19361;
  unsigned int D.19362;
  unsigned int D.19363;
  unsigned int D.19364;
  unsigned int D.19365;
  unsigned int D.19366;
  unsigned int D.19367;
  unsigned int D.19368;
  unsigned int D.19369;
  unsigned int D.19370;
  unsigned int D.19371;
  int D.19372;
  int D.19379;
  long unsigned int D.19380;
  int offset.58;
  sizetype D.19382;
  gchar * D.19383;
  char D.19384;
  int D.19386;
  long unsigned int D.19387;
  int offset.59;
  sizetype D.19389;
  gchar * D.19390;
  int offset.60;
  sizetype D.19392;
  gchar * D.19393;
  sizetype D.19394;
  gchar * D.19395;
  int j.61;
  sizetype D.19397;
  const gchar * D.19398;
  char D.19399;
  int D.19400;
  char D.19401;
  char D.19402;
  int j.62;
  sizetype D.19404;
  const gchar * D.19405;
  char D.19406;
  int D.19407;
  char D.19408;
  signed char D.19409;
  signed char D.19410;
  signed char D.19411;
  char D.19412;
  int D.19413;
  const gchar * pkey;
  gchar header[16];
  gchar val;
  gchar * arr;
  gint i;
  gint j;
  gint offset;
  gint bitlen;
  gint keylen;
  gint pkeylen;

  try
    {
      D.19285 = __strlen_g (key);
      D.19286 = D.19285 >> 1;
      keylen = (gint) D.19286;
      if (keylen <= 0) goto <D.19287>; else goto <D.19288>;
      <D.19287>:
      D.19289 = 0;
      return D.19289;
      <D.19288>:
      D.19290 = strcmp (key, "00000000000000000400000000000000");
      if (D.19290 == 0) goto <D.19291>; else goto <D.19292>;
      <D.19291>:
      if (pubkey != 0B) goto <D.19293>; else goto <D.19294>;
      <D.19293>:
      D.19295 = monoeg_strdup (key);
      *pubkey = D.19295;
      *is_ecma = 1;
      <D.19294>:
      D.19289 = 1;
      return D.19289;
      <D.19292>:
      *is_ecma = 0;
      D.19296 = *key;
      D.19297 = monoeg_g_ascii_xdigit_value (D.19296);
      D.19298 = (char) D.19297;
      val = D.19298 << 4;
      D.19299 = key + 1;
      D.19300 = *D.19299;
      D.19301 = monoeg_g_ascii_xdigit_value (D.19300);
      D.19302 = (signed char) D.19301;
      val.55 = (signed char) val;
      D.19304 = D.19302 | val.55;
      val = (gchar) D.19304;
      D.19305 = (int) val;
      switch (D.19305) <default: <D.17889>, case 0: <D.17886>, case 6: <D.17888>>
      <D.17886>:
      if (keylen <= 12) goto <D.19306>; else goto <D.19307>;
      <D.19306>:
      D.19289 = 0;
      return D.19289;
      <D.19307>:
      D.19308 = key + 24;
      D.19309 = *D.19308;
      D.19310 = monoeg_g_ascii_xdigit_value (D.19309);
      val = (gchar) D.19310;
      D.19311 = key + 25;
      D.19312 = *D.19311;
      D.19313 = monoeg_g_ascii_xdigit_value (D.19312);
      D.19314 = (signed char) D.19313;
      val.55 = (signed char) val;
      D.19315 = D.19314 | val.55;
      val = (gchar) D.19315;
      if (val != 6) goto <D.19316>; else goto <D.19317>;
      <D.19316>:
      D.19289 = 0;
      return D.19289;
      <D.19317>:
      pkey = key + 24;
      goto <D.17887>;
      <D.17888>:
      pkey = key;
      goto <D.17887>;
      <D.17889>:
      D.19289 = 0;
      return D.19289;
      <D.17887>:
      D.19318 = __strlen_g (pkey);
      D.19319 = D.19318 >> 1;
      pkeylen = (gint) D.19319;
      if (pkeylen <= 15) goto <D.19320>; else goto <D.19321>;
      <D.19320>:
      D.19289 = 0;
      return D.19289;
      <D.19321>:
      i = 0;
      j = 0;
      goto <D.17891>;
      <D.17890>:
      j.56 = j;
      j = j.56 + 1;
      D.19323 = (sizetype) j.56;
      D.19324 = pkey + D.19323;
      D.19325 = *D.19324;
      D.19326 = monoeg_g_ascii_xdigit_value (D.19325);
      D.19327 = (char) D.19326;
      D.19328 = D.19327 << 4;
      header[i] = D.19328;
      j.57 = j;
      j = j.57 + 1;
      D.19330 = (sizetype) j.57;
      D.19331 = pkey + D.19330;
      D.19332 = *D.19331;
      D.19333 = monoeg_g_ascii_xdigit_value (D.19332);
      D.19334 = header[i];
      D.19335 = (signed char) D.19334;
      D.19336 = (signed char) D.19333;
      D.19337 = D.19335 | D.19336;
      D.19338 = (char) D.19337;
      header[i] = D.19338;
      i = i + 1;
      <D.17891>:
      if (i <= 15) goto <D.17890>; else goto <D.17892>;
      <D.17892>:
      D.19341 = header[0];
      if (D.19341 != 6) goto <D.19339>; else goto <D.19342>;
      <D.19342>:
      D.19343 = header[1];
      if (D.19343 != 2) goto <D.19339>; else goto <D.19344>;
      <D.19344>:
      D.19345 = header[2];
      if (D.19345 != 0) goto <D.19339>; else goto <D.19346>;
      <D.19346>:
      D.19347 = header[3];
      if (D.19347 != 0) goto <D.19339>; else goto <D.19348>;
      <D.19348>:
      D.19349 = &header + 8;
      D.19350 = *D.19349;
      D.19351 = D.19350 << 24;
      D.19349 = &header + 8;
      D.19350 = *D.19349;
      D.19352 = D.19350 >> 8;
      D.19353 = D.19352 & 65280;
      D.19354 = D.19351 | D.19353;
      D.19349 = &header + 8;
      D.19350 = *D.19349;
      D.19355 = D.19350 << 8;
      D.19356 = D.19355 & 16711680;
      D.19357 = D.19354 | D.19356;
      D.19349 = &header + 8;
      D.19350 = *D.19349;
      D.19358 = D.19350 >> 24;
      D.19359 = D.19357 | D.19358;
      if (D.19359 != 826364754) goto <D.19339>; else goto <D.19340>;
      <D.19339>:
      D.19289 = 0;
      return D.19289;
      <D.19340>:
      D.19360 = &header + 12;
      D.19361 = *D.19360;
      D.19362 = D.19361 << 24;
      D.19360 = &header + 12;
      D.19361 = *D.19360;
      D.19363 = D.19361 >> 8;
      D.19364 = D.19363 & 65280;
      D.19365 = D.19362 | D.19364;
      D.19360 = &header + 12;
      D.19361 = *D.19360;
      D.19366 = D.19361 << 8;
      D.19367 = D.19366 & 16711680;
      D.19368 = D.19365 | D.19367;
      D.19360 = &header + 12;
      D.19361 = *D.19360;
      D.19369 = D.19361 >> 24;
      D.19370 = D.19368 | D.19369;
      D.19371 = D.19370 >> 3;
      bitlen = (gint) D.19371;
      D.19372 = bitlen + 20;
      if (D.19372 != pkeylen) goto <D.19373>; else goto <D.19374>;
      <D.19373>:
      D.19289 = 0;
      return D.19289;
      <D.19374>:
      if (pubkey == 0B) goto <D.19375>; else goto <D.19376>;
      <D.19375>:
      D.19289 = 1;
      return D.19289;
      <D.19376>:
      offset = 0;
      if (keylen <= 127) goto <D.19377>; else goto <D.19378>;
      <D.19377>:
      D.19379 = keylen + 1;
      D.19380 = (long unsigned int) D.19379;
      arr = monoeg_malloc (D.19380);
      offset.58 = offset;
      offset = offset.58 + 1;
      D.19382 = (sizetype) offset.58;
      D.19383 = arr + D.19382;
      D.19384 = (char) keylen;
      *D.19383 = D.19384;
      goto <D.19385>;
      <D.19378>:
      D.19386 = keylen + 2;
      D.19387 = (long unsigned int) D.19386;
      arr = monoeg_malloc (D.19387);
      offset.59 = offset;
      offset = offset.59 + 1;
      D.19389 = (sizetype) offset.59;
      D.19390 = arr + D.19389;
      *D.19390 = 128;
      offset.60 = offset;
      offset = offset.60 + 1;
      D.19392 = (sizetype) offset.60;
      D.19393 = arr + D.19392;
      D.19384 = (char) keylen;
      *D.19393 = D.19384;
      <D.19385>:
      i = offset;
      j = 0;
      goto <D.17894>;
      <D.17893>:
      D.19394 = (sizetype) i;
      D.19395 = arr + D.19394;
      j.61 = j;
      j = j.61 + 1;
      D.19397 = (sizetype) j.61;
      D.19398 = key + D.19397;
      D.19399 = *D.19398;
      D.19400 = monoeg_g_ascii_xdigit_value (D.19399);
      D.19401 = (char) D.19400;
      D.19402 = D.19401 << 4;
      *D.19395 = D.19402;
      j.62 = j;
      j = j.62 + 1;
      D.19404 = (sizetype) j.62;
      D.19405 = key + D.19404;
      D.19406 = *D.19405;
      D.19407 = monoeg_g_ascii_xdigit_value (D.19406);
      D.19394 = (sizetype) i;
      D.19395 = arr + D.19394;
      D.19394 = (sizetype) i;
      D.19395 = arr + D.19394;
      D.19408 = *D.19395;
      D.19409 = (signed char) D.19408;
      D.19410 = (signed char) D.19407;
      D.19411 = D.19409 | D.19410;
      D.19412 = (char) D.19411;
      *D.19395 = D.19412;
      i = i + 1;
      <D.17894>:
      D.19413 = keylen + offset;
      if (D.19413 > i) goto <D.17893>; else goto <D.17895>;
      <D.17895>:
      *pubkey = arr;
      D.19289 = 1;
      return D.19289;
    }
  finally
    {
      header = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_assembly_name_parse (const char * name, struct MonoAssemblyName * aname)
{
  gboolean D.19416;

  D.19416 = mono_assembly_name_parse_full (name, aname, 0, 0B, 0B);
  return D.19416;
}


mono_assembly_name_new (const char * name)
{
  int D.19418;
  struct MonoAssemblyName * D.19421;
  struct MonoAssemblyName * aname;

  aname = monoeg_malloc0 (80);
  D.19418 = mono_assembly_name_parse (name, aname);
  if (D.19418 != 0) goto <D.19419>; else goto <D.19420>;
  <D.19419>:
  D.19421 = aname;
  return D.19421;
  <D.19420>:
  monoeg_g_free (aname);
  D.19421 = 0B;
  return D.19421;
}


mono_assembly_name_get_name (struct MonoAssemblyName * aname)
{
  const char * D.19423;

  D.19423 = aname->name;
  return D.19423;
}


mono_assembly_name_get_culture (struct MonoAssemblyName * aname)
{
  const char * D.19425;

  D.19425 = aname->culture;
  return D.19425;
}


mono_assembly_name_get_pubkeytoken (struct MonoAssemblyName * aname)
{
  unsigned char D.19427;
  mono_byte * D.19430;

  D.19427 = aname->public_key_token[0];
  if (D.19427 != 0) goto <D.19428>; else goto <D.19429>;
  <D.19428>:
  D.19430 = &aname->public_key_token;
  return D.19430;
  <D.19429>:
  D.19430 = 0B;
  return D.19430;
}


mono_assembly_name_get_version (struct MonoAssemblyName * aname, uint16_t * minor, uint16_t * build, uint16_t * revision)
{
  short unsigned int D.19434;
  short unsigned int D.19437;
  short unsigned int D.19440;
  uint16_t D.19441;

  if (minor != 0B) goto <D.19432>; else goto <D.19433>;
  <D.19432>:
  D.19434 = aname->minor;
  *minor = D.19434;
  <D.19433>:
  if (build != 0B) goto <D.19435>; else goto <D.19436>;
  <D.19435>:
  D.19437 = aname->build;
  *build = D.19437;
  <D.19436>:
  if (revision != 0B) goto <D.19438>; else goto <D.19439>;
  <D.19438>:
  D.19440 = aname->revision;
  *revision = D.19440;
  <D.19439>:
  D.19441 = aname->major;
  return D.19441;
}


mono_assembly_load_with_partial_name (const char * name, MonoImageOpenStatus * status)
{
  int D.19443;
  struct MonoAssembly * D.19446;
  short unsigned int D.19447;
  short unsigned int D.19448;
  short unsigned int D.19449;
  short unsigned int D.19450;
  short unsigned int D.19451;
  short unsigned int D.19452;
  short unsigned int D.19453;
  char * * assemblies_path.63;
  const char * D.19461;
  char * * extra_gac_paths.64;
  gchar * D.19465;
  const char * D.19469;
  struct MonoString * D.19473;
  struct MonoAssembly * res;
  struct MonoAssemblyName * aname;
  struct MonoAssemblyName base_name;
  struct MonoAssemblyName mapped_aname;
  gchar * fullname;
  gchar * gacpath;
  gchar * * paths;

  try
    {
      memset (&base_name, 0, 80);
      aname = &base_name;
      D.19443 = mono_assembly_name_parse (name, aname);
      if (D.19443 == 0) goto <D.19444>; else goto <D.19445>;
      <D.19444>:
      D.19446 = 0B;
      return D.19446;
      <D.19445>:
      D.19447 = aname->major;
      D.19448 = aname->minor;
      D.19449 = D.19447 | D.19448;
      D.19450 = aname->build;
      D.19451 = D.19449 | D.19450;
      D.19452 = aname->revision;
      D.19453 = D.19451 | D.19452;
      if (D.19453 == 0) goto <D.19454>; else goto <D.19455>;
      <D.19454>:
      aname = mono_assembly_remap_version (aname, &mapped_aname);
      <D.19455>:
      res = mono_assembly_loaded (aname);
      if (res != 0B) goto <D.19456>; else goto <D.19457>;
      <D.19456>:
      mono_assembly_name_free (aname);
      D.19446 = res;
      return D.19446;
      <D.19457>:
      assemblies_path.63 = assemblies_path;
      res = invoke_assembly_preload_hook (aname, assemblies_path.63);
      if (res != 0B) goto <D.19459>; else goto <D.19460>;
      <D.19459>:
      res->in_gac = 0;
      mono_assembly_name_free (aname);
      D.19446 = res;
      return D.19446;
      <D.19460>:
      D.19461 = aname->name;
      fullname = monoeg_g_strdup_printf ("%s.dll", D.19461);
      extra_gac_paths.64 = extra_gac_paths;
      if (extra_gac_paths.64 != 0B) goto <D.19463>; else goto <D.19464>;
      <D.19463>:
      paths = extra_gac_paths;
      goto <D.18018>;
      <D.18017>:
      D.19465 = *paths;
      D.19461 = aname->name;
      gacpath = monoeg_g_build_path ("/", D.19465, "lib", "mono", "gac", D.19461, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      paths = paths + 8;
      <D.18018>:
      if (res == 0B) goto <D.19466>; else goto <D.18019>;
      <D.19466>:
      D.19465 = *paths;
      if (D.19465 != 0B) goto <D.18017>; else goto <D.18019>;
      <D.18019>:
      <D.19464>:
      if (res != 0B) goto <D.19467>; else goto <D.19468>;
      <D.19467>:
      res->in_gac = 1;
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.19446 = res;
      return D.19446;
      <D.19468>:
      D.19469 = mono_assembly_getrootdir ();
      D.19461 = aname->name;
      gacpath = monoeg_g_build_path ("/", D.19469, "mono", "gac", D.19461, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      if (res != 0B) goto <D.19470>; else goto <D.19471>;
      <D.19470>:
      res->in_gac = 1;
      goto <D.19472>;
      <D.19471>:
      {
        struct MonoDomain * domain;
        struct MonoReflectionAssembly * refasm;

        domain = mono_domain_get ();
        D.19473 = mono_string_new (domain, name);
        refasm = mono_try_assembly_resolve (domain, D.19473, 0);
        if (refasm != 0B) goto <D.19474>; else goto <D.19475>;
        <D.19474>:
        res = refasm->assembly;
        <D.19475>:
      }
      <D.19472>:
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.19446 = res;
      return D.19446;
    }
  finally
    {
      base_name = {CLOBBER};
      mapped_aname = {CLOBBER};
    }
}


mono_assembly_remap_version (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_aname)
{
  const char * D.19478;
  struct MonoAssemblyName * D.19481;
  unsigned int D.19482;
  unsigned int D.19483;
  short unsigned int D.19486;
  short unsigned int D.19487;
  short unsigned int D.19488;
  short unsigned int D.19489;
  unsigned int D.19490;
  unsigned int D.19491;
  int D.19492;
  gchar * D.19495;
  short unsigned int D.19496;
  int D.19497;
  short unsigned int D.19498;
  int D.19499;
  short unsigned int D.19500;
  int D.19501;
  short unsigned int D.19502;
  int D.19503;
  const char * D.19504;
  int D.19505;
  int D.19506;
  int D.19507;
  int D.19508;
  int D.19509;
  int D.19510;
  const char * D.19511;
  unsigned char D.19514;
  unsigned int index.65;
  _Bool D.19516;
  long int D.19517;
  long int D.19518;
  short unsigned int D.19521;
  short unsigned int D.19524;
  short unsigned int D.19527;
  short unsigned int D.19530;
  short unsigned int D.19533;
  short unsigned int D.19534;
  short unsigned int D.19535;
  int D.19538;
  int D.19539;
  int D.19540;
  int D.19541;
  const struct MonoRuntimeInfo * current_runtime;
  int pos;
  int first;
  int last;

  D.19478 = aname->name;
  if (D.19478 == 0B) goto <D.19479>; else goto <D.19480>;
  <D.19479>:
  D.19481 = aname;
  return D.19481;
  <D.19480>:
  current_runtime = mono_get_runtime_info ();
  D.19482 = aname->flags;
  D.19483 = D.19482 & 256;
  if (D.19483 != 0) goto <D.19484>; else goto <D.19485>;
  <D.19484>:
  {
    const struct AssemblyVersionSet * vset;

    vset = &current_runtime->version_sets[0];
    memcpy (dest_aname, aname, 80);
    D.19486 = vset->major;
    dest_aname->major = D.19486;
    D.19487 = vset->minor;
    dest_aname->minor = D.19487;
    D.19488 = vset->build;
    dest_aname->build = D.19488;
    D.19489 = vset->revision;
    dest_aname->revision = D.19489;
    D.19490 = dest_aname->flags;
    D.19491 = D.19490 & 4294967039;
    dest_aname->flags = D.19491;
    D.19478 = aname->name;
    D.19492 = strcmp (D.19478, "System.Net");
    if (D.19492 == 0) goto <D.19493>; else goto <D.19494>;
    <D.19493>:
    D.19495 = monoeg_strdup ("System");
    dest_aname->name = D.19495;
    <D.19494>:
    remap_keys (dest_aname);
    D.19478 = aname->name;
    D.19496 = aname->major;
    D.19497 = (int) D.19496;
    D.19498 = aname->minor;
    D.19499 = (int) D.19498;
    D.19500 = aname->build;
    D.19501 = (int) D.19500;
    D.19502 = aname->revision;
    D.19503 = (int) D.19502;
    D.19504 = dest_aname->name;
    D.19486 = vset->major;
    D.19505 = (int) D.19486;
    D.19487 = vset->minor;
    D.19506 = (int) D.19487;
    D.19488 = vset->build;
    D.19507 = (int) D.19488;
    D.19489 = vset->revision;
    D.19508 = (int) D.19489;
    mono_trace (64, 1, "The request to load the retargetable assembly %s v%d.%d.%d.%d was remapped to %s v%d.%d.%d.%d", D.19478, D.19497, D.19499, D.19501, D.19503, D.19504, D.19505, D.19506, D.19507, D.19508);
    D.19481 = dest_aname;
    return D.19481;
  }
  <D.19485>:
  first = 0;
  last = 62;
  goto <D.17624>;
  <D.17623>:
  {
    int res;

    D.19509 = last - first;
    D.19510 = D.19509 / 2;
    pos = D.19510 + first;
    D.19478 = aname->name;
    D.19511 = framework_assemblies[pos].assembly_name;
    res = strcmp (D.19478, D.19511);
    if (res == 0) goto <D.19512>; else goto <D.19513>;
    <D.19512>:
    {
      const struct AssemblyVersionSet * vset;
      int index;

      D.19514 = framework_assemblies[pos].version_set_index;
      index = (int) D.19514;
      index.65 = (unsigned int) index;
      D.19516 = index.65 > 3;
      D.19517 = (long int) D.19516;
      D.19518 = __builtin_expect (D.19517, 0);
      if (D.19518 != 0) goto <D.19519>; else goto <D.19520>;
      <D.19519>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 995, "index < G_N_ELEMENTS (current_runtime->version_sets)");
      <D.19520>:
      vset = &current_runtime->version_sets[index];
      D.19496 = aname->major;
      D.19521 = vset->major;
      if (D.19496 == D.19521) goto <D.19522>; else goto <D.19523>;
      <D.19522>:
      D.19498 = aname->minor;
      D.19524 = vset->minor;
      if (D.19498 == D.19524) goto <D.19525>; else goto <D.19526>;
      <D.19525>:
      D.19500 = aname->build;
      D.19527 = vset->build;
      if (D.19500 == D.19527) goto <D.19528>; else goto <D.19529>;
      <D.19528>:
      D.19502 = aname->revision;
      D.19530 = vset->revision;
      if (D.19502 == D.19530) goto <D.19531>; else goto <D.19532>;
      <D.19531>:
      D.19481 = aname;
      return D.19481;
      <D.19532>:
      <D.19529>:
      <D.19526>:
      <D.19523>:
      D.19496 = aname->major;
      D.19498 = aname->minor;
      D.19533 = D.19496 | D.19498;
      D.19500 = aname->build;
      D.19534 = D.19533 | D.19500;
      D.19502 = aname->revision;
      D.19535 = D.19534 | D.19502;
      if (D.19535 != 0) goto <D.19536>; else goto <D.19537>;
      <D.19536>:
      D.19478 = aname->name;
      D.19496 = aname->major;
      D.19497 = (int) D.19496;
      D.19498 = aname->minor;
      D.19499 = (int) D.19498;
      D.19500 = aname->build;
      D.19501 = (int) D.19500;
      D.19502 = aname->revision;
      D.19503 = (int) D.19502;
      D.19521 = vset->major;
      D.19538 = (int) D.19521;
      D.19524 = vset->minor;
      D.19539 = (int) D.19524;
      D.19527 = vset->build;
      D.19540 = (int) D.19527;
      D.19530 = vset->revision;
      D.19541 = (int) D.19530;
      mono_trace (16, 1, "The request to load the assembly %s v%d.%d.%d.%d was remapped to v%d.%d.%d.%d", D.19478, D.19497, D.19499, D.19501, D.19503, D.19538, D.19539, D.19540, D.19541);
      <D.19537>:
      memcpy (dest_aname, aname, 80);
      D.19521 = vset->major;
      dest_aname->major = D.19521;
      D.19524 = vset->minor;
      dest_aname->minor = D.19524;
      D.19527 = vset->build;
      dest_aname->build = D.19527;
      D.19530 = vset->revision;
      dest_aname->revision = D.19530;
      D.19481 = dest_aname;
      return D.19481;
    }
    <D.19513>:
    if (res < 0) goto <D.19542>; else goto <D.19543>;
    <D.19542>:
    last = pos + -1;
    goto <D.19544>;
    <D.19543>:
    first = pos + 1;
    <D.19544>:
  }
  <D.17624>:
  if (first <= last) goto <D.17623>; else goto <D.17625>;
  <D.17625>:
  D.19481 = aname;
  return D.19481;
}


remap_keys (struct MonoAssemblyName * aname)
{
  const char * D.19548;
  const char * D.19549;
  int D.19550;
  mono_byte[17] * D.19552;
  const char * D.19553;
  int D.19554;
  const char * D.19555;
  unsigned int i.66;
  int i;

  i = 0;
  goto <D.17609>;
  <D.17608>:
  {
    const struct KeyRemapEntry * entry;

    entry = &key_remap_table[i];
    D.19548 = aname->name;
    D.19549 = entry->name;
    D.19550 = strcmp (D.19548, D.19549);
    if (D.19550 != 0) goto <D.19546>; else goto <D.19551>;
    <D.19551>:
    D.19552 = &aname->public_key_token;
    D.19553 = entry->from;
    D.19554 = mono_public_tokens_are_equal (D.19552, D.19553);
    if (D.19554 == 0) goto <D.19546>; else goto <D.19547>;
    <D.19546>:
    // predicted unlikely by continue predictor.
    goto <D.17607>;
    <D.19547>:
    D.19552 = &aname->public_key_token;
    D.19555 = entry->to;
    memcpy (D.19552, D.19555, 17);
    D.19548 = aname->name;
    D.19553 = entry->from;
    D.19555 = entry->to;
    mono_trace (64, 1, "Remapped public key token of retargetable assembly %s from %s to %s", D.19548, D.19553, D.19555);
    return;
  }
  <D.17607>:
  i = i + 1;
  <D.17609>:
  i.66 = (unsigned int) i;
  if (i.66 <= 13) goto <D.17608>; else goto <D.17610>;
  <D.17610>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.19558;
  long unsigned int D.19559;

  D.19559 = __builtin_object_size (__dest, 0);
  D.19558 = __builtin___memcpy_chk (__dest, __src, __len, D.19559);
  return D.19558;
}


invoke_assembly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<T1040>) (struct MonoAssemblyName *, char * *, void *) D.19561;
  void * D.19562;
  struct MonoAssembly * D.19565;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_preload_hook;
  goto <D.17744>;
  <D.17743>:
  D.19561 = hook->func;
  D.19562 = hook->user_data;
  assembly = D.19561 (aname, assemblies_path, D.19562);
  if (assembly != 0B) goto <D.19563>; else goto <D.19564>;
  <D.19563>:
  D.19565 = assembly;
  return D.19565;
  <D.19564>:
  hook = hook->next;
  <D.17744>:
  if (hook != 0B) goto <D.17743>; else goto <D.17745>;
  <D.17745>:
  D.19565 = 0B;
  return D.19565;
}


probe_for_partial_name (const char * basepath, const char * fullname, struct MonoAssemblyName * aname, MonoImageOpenStatus * status)
{
  struct MonoAssembly * D.19569;
  short unsigned int D.19570;
  short unsigned int D.19571;
  short unsigned int D.19572;
  short unsigned int D.19573;
  short unsigned int D.19574;
  short unsigned int D.19575;
  short unsigned int D.19576;
  _Bool D.19577;
  const char * D.19578;
  int D.19579;
  const char * D.19582;
  const char * D.19585;
  int D.19586;
  mono_byte[17] * D.19591;
  long unsigned int D.19592;
  int D.19595;
  long unsigned int D.19602;
  long unsigned int D.19603;
  long unsigned int D.19604;
  long unsigned int D.19605;
  _Bool D.19606;
  short unsigned int D.19608;
  int D.19609;
  short unsigned int D.19615;
  int D.19616;
  short unsigned int D.19622;
  int D.19623;
  short unsigned int D.19629;
  int D.19630;
  gchar * fullpath;
  struct GDir * dirhandle;
  const char * direntry;
  struct MonoAssemblyName gac_aname;
  gint major;
  gint minor;
  gint build;
  gint revision;
  gboolean exact_version;

  try
    {
      fullpath = 0B;
      major = -1;
      minor = 0;
      build = 0;
      revision = 0;
      dirhandle = monoeg_g_dir_open (basepath, 0, 0B);
      if (dirhandle == 0B) goto <D.19567>; else goto <D.19568>;
      <D.19567>:
      D.19569 = 0B;
      return D.19569;
      <D.19568>:
      D.19570 = aname->major;
      D.19571 = aname->minor;
      D.19572 = D.19570 | D.19571;
      D.19573 = aname->build;
      D.19574 = D.19572 | D.19573;
      D.19575 = aname->revision;
      D.19576 = D.19574 | D.19575;
      D.19577 = D.19576 != 0;
      exact_version = (gboolean) D.19577;
      goto <D.18002>;
      <D.18003>:
      {
        gboolean match;

        match = 1;
        D.19578 = aname->name;
        D.19579 = parse_assembly_directory_name (D.19578, direntry, &gac_aname);
        if (D.19579 == 0) goto <D.19580>; else goto <D.19581>;
        <D.19580>:
        // predicted unlikely by continue predictor.
        goto <D.18002>;
        <D.19581>:
        D.19582 = aname->culture;
        if (D.19582 != 0B) goto <D.19583>; else goto <D.19584>;
        <D.19583>:
        D.19582 = aname->culture;
        D.19585 = gac_aname.culture;
        D.19586 = strcmp (D.19582, D.19585);
        if (D.19586 != 0) goto <D.19587>; else goto <D.19588>;
        <D.19587>:
        match = 0;
        <D.19588>:
        <D.19584>:
        if (match != 0) goto <D.19589>; else goto <D.19590>;
        <D.19589>:
        D.19591 = &aname->public_key_token;
        D.19592 = __strlen_g (D.19591);
        if (D.19592 != 0) goto <D.19593>; else goto <D.19594>;
        <D.19593>:
        D.19591 = &aname->public_key_token;
        D.19595 = mono_public_tokens_are_equal (D.19591, &gac_aname.public_key_token);
        if (D.19595 == 0) goto <D.19596>; else goto <D.19597>;
        <D.19596>:
        match = 0;
        <D.19597>:
        <D.19594>:
        <D.19590>:
        if (match != 0) goto <D.19598>; else goto <D.19599>;
        <D.19598>:
        if (exact_version != 0) goto <D.19600>; else goto <D.19601>;
        <D.19600>:
        D.19602 = BIT_FIELD_REF <*aname, 64, 512>;
        D.19603 = D.19602;
        D.19604 = BIT_FIELD_REF <gac_aname, 64, 512>;
        D.19605 = D.19604;
        D.19606 = D.19603 == D.19605;
        match = (gboolean) D.19606;
        goto <D.19607>;
        <D.19601>:
        D.19608 = gac_aname.major;
        D.19609 = (int) D.19608;
        if (D.19609 < major) goto <D.19610>; else goto <D.19611>;
        <D.19610>:
        match = 0;
        goto <D.19612>;
        <D.19611>:
        D.19608 = gac_aname.major;
        D.19609 = (int) D.19608;
        if (D.19609 == major) goto <D.19613>; else goto <D.19614>;
        <D.19613>:
        D.19615 = gac_aname.minor;
        D.19616 = (int) D.19615;
        if (D.19616 < minor) goto <D.19617>; else goto <D.19618>;
        <D.19617>:
        match = 0;
        goto <D.19619>;
        <D.19618>:
        D.19615 = gac_aname.minor;
        D.19616 = (int) D.19615;
        if (D.19616 == minor) goto <D.19620>; else goto <D.19621>;
        <D.19620>:
        D.19622 = gac_aname.build;
        D.19623 = (int) D.19622;
        if (D.19623 < build) goto <D.19624>; else goto <D.19625>;
        <D.19624>:
        match = 0;
        goto <D.19626>;
        <D.19625>:
        D.19622 = gac_aname.build;
        D.19623 = (int) D.19622;
        if (D.19623 == build) goto <D.19627>; else goto <D.19628>;
        <D.19627>:
        D.19629 = gac_aname.revision;
        D.19630 = (int) D.19629;
        if (D.19630 <= revision) goto <D.19631>; else goto <D.19632>;
        <D.19631>:
        match = 0;
        <D.19632>:
        <D.19628>:
        <D.19626>:
        <D.19621>:
        <D.19619>:
        <D.19614>:
        <D.19612>:
        <D.19607>:
        <D.19599>:
        if (match != 0) goto <D.19633>; else goto <D.19634>;
        <D.19633>:
        D.19608 = gac_aname.major;
        major = (gint) D.19608;
        D.19615 = gac_aname.minor;
        minor = (gint) D.19615;
        D.19622 = gac_aname.build;
        build = (gint) D.19622;
        D.19629 = gac_aname.revision;
        revision = (gint) D.19629;
        monoeg_g_free (fullpath);
        fullpath = monoeg_g_build_path ("/", basepath, direntry, fullname, 0B);
        <D.19634>:
        mono_assembly_name_free (&gac_aname);
      }
      <D.18002>:
      direntry = monoeg_g_dir_read_name (dirhandle);
      if (direntry != 0B) goto <D.18003>; else goto <D.18004>;
      <D.18004>:
      monoeg_g_dir_close (dirhandle);
      if (fullpath == 0B) goto <D.19635>; else goto <D.19636>;
      <D.19635>:
      D.19569 = 0B;
      return D.19569;
      <D.19636>:
      {
        struct MonoAssembly * res;

        res = mono_assembly_open (fullpath, status);
        monoeg_g_free (fullpath);
        D.19569 = res;
        return D.19569;
      }
    }
  finally
    {
      gac_aname = {CLOBBER};
    }
}


parse_assembly_directory_name (const char * name, const char * dirname, struct MonoAssemblyName * aname)
{
  gchar * D.19642;
  gchar * * D.19644;
  gchar * D.19645;
  gchar * * D.19647;
  gchar * D.19648;
  gboolean D.19649;
  gchar * * parts;
  gboolean res;

  parts = monoeg_g_strsplit (dirname, "_", 3);
  if (parts == 0B) goto <D.19639>; else goto <D.19641>;
  <D.19641>:
  D.19642 = *parts;
  if (D.19642 == 0B) goto <D.19639>; else goto <D.19643>;
  <D.19643>:
  D.19644 = parts + 8;
  D.19645 = *D.19644;
  if (D.19645 == 0B) goto <D.19639>; else goto <D.19646>;
  <D.19646>:
  D.19647 = parts + 16;
  D.19648 = *D.19647;
  if (D.19648 == 0B) goto <D.19639>; else goto <D.19640>;
  <D.19639>:
  monoeg_g_strfreev (parts);
  D.19649 = 0;
  return D.19649;
  <D.19640>:
  D.19642 = *parts;
  D.19644 = parts + 8;
  D.19645 = *D.19644;
  D.19647 = parts + 16;
  D.19648 = *D.19647;
  res = build_assembly_name (name, D.19642, D.19645, D.19648, 0B, 0, 0, aname, 0);
  monoeg_g_strfreev (parts);
  D.19649 = res;
  return D.19649;
}


__attribute__((visibility ("hidden")))
mono_assembly_load_corlib (const struct MonoRuntimeInfo * runtime, MonoImageOpenStatus * status)
{
  struct MonoAssembly * corlib.67;
  struct MonoAssembly * D.19654;
  char * * assemblies_path.68;
  struct MonoAssembly * D.19656;
  struct MonoAssembly * D.19661;
  const char[4] * D.19664;
  struct MonoAssembly * D.19667;
  struct MonoAssembly * D.19670;
  int D.19673;
  const char * D.19676;
  gchar * D.19677;
  char * corlib_file;
  struct MonoAssemblyName * aname;

  corlib.67 = corlib;
  if (corlib.67 != 0B) goto <D.19652>; else goto <D.19653>;
  <D.19652>:
  D.19654 = corlib;
  return D.19654;
  <D.19653>:
  aname = mono_assembly_name_new ("mscorlib.dll");
  assemblies_path.68 = assemblies_path;
  D.19656 = invoke_assembly_preload_hook (aname, assemblies_path.68);
  corlib = D.19656;
  mono_assembly_name_free (aname);
  monoeg_g_free (aname);
  corlib.67 = corlib;
  if (corlib.67 != 0B) goto <D.19657>; else goto <D.19658>;
  <D.19657>:
  D.19654 = corlib;
  return D.19654;
  <D.19658>:
  assemblies_path.68 = assemblies_path;
  if (assemblies_path.68 != 0B) goto <D.19659>; else goto <D.19660>;
  <D.19659>:
  assemblies_path.68 = assemblies_path;
  D.19661 = load_in_path ("mscorlib.dll", assemblies_path.68, status, 0);
  corlib = D.19661;
  corlib.67 = corlib;
  if (corlib.67 != 0B) goto <D.19662>; else goto <D.19663>;
  <D.19662>:
  D.19654 = corlib;
  return D.19654;
  <D.19663>:
  <D.19660>:
  D.19664 = &runtime->framework_version;
  corlib_file = monoeg_g_build_path ("/", "mono", D.19664, "mscorlib.dll", 0B);
  assemblies_path.68 = assemblies_path;
  if (assemblies_path.68 != 0B) goto <D.19665>; else goto <D.19666>;
  <D.19665>:
  assemblies_path.68 = assemblies_path;
  D.19667 = load_in_path (corlib_file, assemblies_path.68, status, 0);
  corlib = D.19667;
  corlib.67 = corlib;
  if (corlib.67 != 0B) goto <D.19668>; else goto <D.19669>;
  <D.19668>:
  monoeg_g_free (corlib_file);
  D.19654 = corlib;
  return D.19654;
  <D.19669>:
  <D.19666>:
  D.19670 = load_in_path (corlib_file, &default_path, status, 0);
  corlib = D.19670;
  monoeg_g_free (corlib_file);
  corlib.67 = corlib;
  if (corlib.67 != 0B) goto <D.19671>; else goto <D.19672>;
  <D.19671>:
  D.19664 = &runtime->framework_version;
  D.19673 = strcmp (D.19664, "4.5");
  if (D.19673 == 0) goto <D.19674>; else goto <D.19675>;
  <D.19674>:
  D.19676 = default_path[0];
  D.19677 = monoeg_g_strdup_printf ("%s/mono/4.5/Facades", D.19676);
  default_path[1] = D.19677;
  <D.19675>:
  <D.19672>:
  D.19654 = corlib;
  return D.19654;
}


load_in_path (const char * basename, const char * * search_path, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  long unsigned int D.19679;
  long unsigned int D.19680;
  const char * * D.19681;
  const char * D.19682;
  int D.19683;
  struct MonoAssembly * D.19686;
  int i;
  char * fullpath;
  struct MonoAssembly * result;

  i = 0;
  goto <D.17521>;
  <D.17520>:
  D.19679 = (long unsigned int) i;
  D.19680 = D.19679 * 8;
  D.19681 = search_path + D.19680;
  D.19682 = *D.19681;
  fullpath = monoeg_g_build_path ("/", D.19682, basename, 0B);
  D.19683 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.19683);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.19684>; else goto <D.19685>;
  <D.19684>:
  D.19686 = result;
  return D.19686;
  <D.19685>:
  i = i + 1;
  <D.17521>:
  D.19679 = (long unsigned int) i;
  D.19680 = D.19679 * 8;
  D.19681 = search_path + D.19680;
  D.19682 = *D.19681;
  if (D.19682 != 0B) goto <D.17520>; else goto <D.17522>;
  <D.17522>:
  D.19686 = 0B;
  return D.19686;
}


__attribute__((visibility ("hidden")))
mono_assembly_load_full_nosearch (struct MonoAssemblyName * aname, const char * basedir, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.19692;
  struct MonoAssembly * iftmp.69;
  char * * assemblies_path.70;
  const char * D.19702;
  int D.19703;
  int D.19705;
  const struct MonoRuntimeInfo * D.19706;
  long unsigned int D.19707;
  const char * iftmp.71;
  sizetype D.19716;
  sizetype D.19717;
  const char * D.19718;
  int D.19719;
  int D.19721;
  unsigned char D.19722;
  struct MonoAssembly * result;
  char * fullpath;
  char * filename;
  struct MonoAssemblyName maped_aname;
  struct MonoAssemblyName maped_name_pp;
  int ext_index;
  const char * ext;
  int len;

  try
    {
      aname = mono_assembly_remap_version (aname, &maped_aname);
      if (refonly == 0) goto <D.19688>; else goto <D.19689>;
      <D.19688>:
      aname = mono_assembly_apply_binding (aname, &maped_name_pp);
      <D.19689>:
      result = mono_assembly_loaded_full (aname, refonly);
      if (result != 0B) goto <D.19690>; else goto <D.19691>;
      <D.19690>:
      D.19692 = result;
      return D.19692;
      <D.19691>:
      if (refonly != 0) goto <D.19694>; else goto <D.19695>;
      <D.19694>:
      assemblies_path.70 = assemblies_path;
      iftmp.69 = invoke_assembly_refonly_preload_hook (aname, assemblies_path.70);
      goto <D.19697>;
      <D.19695>:
      assemblies_path.70 = assemblies_path;
      iftmp.69 = invoke_assembly_preload_hook (aname, assemblies_path.70);
      <D.19697>:
      result = iftmp.69;
      if (result != 0B) goto <D.19698>; else goto <D.19699>;
      <D.19698>:
      result->in_gac = 0;
      D.19692 = result;
      return D.19692;
      <D.19699>:
      D.19702 = aname->name;
      D.19703 = strcmp (D.19702, "mscorlib");
      if (D.19703 == 0) goto <D.19700>; else goto <D.19704>;
      <D.19704>:
      D.19702 = aname->name;
      D.19705 = strcmp (D.19702, "mscorlib.dll");
      if (D.19705 == 0) goto <D.19700>; else goto <D.19701>;
      <D.19700>:
      D.19706 = mono_get_runtime_info ();
      D.19692 = mono_assembly_load_corlib (D.19706, status);
      return D.19692;
      <D.19701>:
      D.19702 = aname->name;
      D.19707 = __strlen_g (D.19702);
      len = (int) D.19707;
      ext_index = 0;
      goto <D.18151>;
      <D.18150>:
      if (ext_index == 0) goto <D.19709>; else goto <D.19710>;
      <D.19709>:
      iftmp.71 = ".dll";
      goto <D.19711>;
      <D.19710>:
      iftmp.71 = ".exe";
      <D.19711>:
      ext = iftmp.71;
      if (len > 4) goto <D.19715>; else goto <D.19712>;
      <D.19715>:
      D.19702 = aname->name;
      D.19716 = (sizetype) len;
      D.19717 = D.19716 + 18446744073709551612;
      D.19718 = D.19702 + D.19717;
      D.19719 = strcmp (D.19718, ".dll");
      if (D.19719 == 0) goto <D.19713>; else goto <D.19720>;
      <D.19720>:
      D.19702 = aname->name;
      D.19716 = (sizetype) len;
      D.19717 = D.19716 + 18446744073709551612;
      D.19718 = D.19702 + D.19717;
      D.19721 = strcmp (D.19718, ".exe");
      if (D.19721 == 0) goto <D.19713>; else goto <D.19712>;
      <D.19713>:
      D.19702 = aname->name;
      filename = monoeg_strdup (D.19702);
      ext_index = ext_index + 1;
      goto <D.19714>;
      <D.19712>:
      D.19702 = aname->name;
      filename = monoeg_g_strconcat (D.19702, ext, 0B);
      <D.19714>:
      D.19722 = (unsigned char) refonly;
      result = mono_assembly_load_from_gac (aname, filename, status, D.19722);
      if (result != 0B) goto <D.19723>; else goto <D.19724>;
      <D.19723>:
      monoeg_g_free (filename);
      D.19692 = result;
      return D.19692;
      <D.19724>:
      if (basedir != 0B) goto <D.19725>; else goto <D.19726>;
      <D.19725>:
      fullpath = monoeg_g_build_path ("/", basedir, filename, 0B);
      result = mono_assembly_open_full (fullpath, status, refonly);
      monoeg_g_free (fullpath);
      if (result != 0B) goto <D.19727>; else goto <D.19728>;
      <D.19727>:
      result->in_gac = 0;
      monoeg_g_free (filename);
      D.19692 = result;
      return D.19692;
      <D.19728>:
      <D.19726>:
      D.19722 = (unsigned char) refonly;
      result = load_in_path (filename, &default_path, status, D.19722);
      if (result != 0B) goto <D.19729>; else goto <D.19730>;
      <D.19729>:
      result->in_gac = 0;
      <D.19730>:
      monoeg_g_free (filename);
      if (result != 0B) goto <D.19731>; else goto <D.19732>;
      <D.19731>:
      D.19692 = result;
      return D.19692;
      <D.19732>:
      ext_index = ext_index + 1;
      <D.18151>:
      if (ext_index <= 1) goto <D.18150>; else goto <D.18152>;
      <D.18152>:
      D.19692 = result;
      return D.19692;
    }
  finally
    {
      maped_aname = {CLOBBER};
      maped_name_pp = {CLOBBER};
    }
}


mono_assembly_apply_binding (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  unsigned char D.19735;
  struct MonoAssemblyName * D.19738;
  union mono_mutex_t * D.19741;
  _Bool D.19744;
  long int D.19745;
  long int D.19746;
  _Bool D.19751;
  long int D.19752;
  long int D.19753;
  int D.19758;
  struct MonoAppDomainSetup * D.19763;
  struct MonoString * D.19766;
  _Bool D.19771;
  long int D.19772;
  long int D.19773;
  int D.19776;
  short unsigned int D.19781;
  int D.19782;
  short unsigned int D.19783;
  int D.19784;
  char * D.19789;
  gchar * D.19790;
  char * D.19791;
  gchar * D.19792;
  int D.19793;
  _Bool D.19796;
  long int D.19797;
  long int D.19798;
  long unsigned int D.19803;
  long unsigned int D.19804;
  const char * D.19811;
  gchar * D.19812;
  const char * D.19813;
  gchar * D.19814;
  guchar[17] * D.19815;
  mono_byte[17] * D.19816;
  struct GSList * loaded_assembly_bindings.72;
  struct GSList * D.19821;
  int D.19825;
  struct MonoAssemblyBindingInfo * info;
  struct MonoAssemblyBindingInfo * info2;
  struct MonoImage * ppimage;
  struct MonoDomain * domain;

  D.19735 = aname->public_key_token[0];
  if (D.19735 == 0) goto <D.19736>; else goto <D.19737>;
  <D.19736>:
  D.19738 = aname;
  return D.19738;
  <D.19737>:
  domain = mono_domain_get ();
  mono_assembly_binding_lock ();
  info = search_binding_loaded (aname);
  mono_assembly_binding_unlock ();
  if (info == 0B) goto <D.19739>; else goto <D.19740>;
  <D.19739>:
  {
    int ret;

    D.19741 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19741);
    if (ret != 0) goto <D.19742>; else goto <D.19743>;
    <D.19742>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19743>:
    D.19744 = ret != 0;
    D.19745 = (long int) D.19744;
    D.19746 = __builtin_expect (D.19745, 0);
    if (D.19746 != 0) goto <D.19747>; else goto <D.19748>;
    <D.19747>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2644, "ret == 0");
    <D.19748>:
  }
  info = get_per_domain_assembly_binding_info (domain, aname);
  {
    int ret;

    D.19741 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.19741);
    if (ret != 0) goto <D.19749>; else goto <D.19750>;
    <D.19749>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19750>:
    D.19751 = ret != 0;
    D.19752 = (long int) D.19751;
    D.19753 = __builtin_expect (D.19752, 0);
    if (D.19753 != 0) goto <D.19754>; else goto <D.19755>;
    <D.19754>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2646, "ret == 0");
    <D.19755>:
  }
  <D.19740>:
  if (info != 0B) goto <D.19756>; else goto <D.19757>;
  <D.19756>:
  D.19758 = check_policy_versions (info, aname);
  if (D.19758 == 0) goto <D.19759>; else goto <D.19760>;
  <D.19759>:
  D.19738 = aname;
  return D.19738;
  <D.19760>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.19738 = dest_name;
  return D.19738;
  <D.19757>:
  if (domain != 0B) goto <D.19761>; else goto <D.19762>;
  <D.19761>:
  D.19763 = domain->setup;
  if (D.19763 != 0B) goto <D.19764>; else goto <D.19765>;
  <D.19764>:
  D.19763 = domain->setup;
  D.19766 = D.19763->configuration_file;
  if (D.19766 != 0B) goto <D.19767>; else goto <D.19768>;
  <D.19767>:
  {
    int ret;

    D.19741 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19741);
    if (ret != 0) goto <D.19769>; else goto <D.19770>;
    <D.19769>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19770>:
    D.19771 = ret != 0;
    D.19772 = (long int) D.19771;
    D.19773 = __builtin_expect (D.19772, 0);
    if (D.19773 != 0) goto <D.19774>; else goto <D.19775>;
    <D.19774>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2658, "ret == 0");
    <D.19775>:
  }
  D.19776 = domain->assembly_bindings_parsed;
  if (D.19776 == 0) goto <D.19777>; else goto <D.19778>;
  <D.19777>:
  {
    gchar * domain_config_file_name;
    gchar * domain_config_file_path;

    D.19763 = domain->setup;
    D.19766 = D.19763->configuration_file;
    domain_config_file_name = mono_string_to_utf8 (D.19766);
    domain_config_file_path = mono_portability_find_file (domain_config_file_name, 1);
    if (domain_config_file_path == 0B) goto <D.19779>; else goto <D.19780>;
    <D.19779>:
    domain_config_file_path = domain_config_file_name;
    <D.19780>:
    D.19781 = aname->major;
    D.19782 = (int) D.19781;
    D.19783 = aname->minor;
    D.19784 = (int) D.19783;
    mono_config_parse_assembly_bindings (domain_config_file_path, D.19782, D.19784, domain, assembly_binding_info_parsed);
    domain->assembly_bindings_parsed = 1;
    if (domain_config_file_name != domain_config_file_path) goto <D.19785>; else goto <D.19786>;
    <D.19785>:
    monoeg_g_free (domain_config_file_name);
    <D.19786>:
    monoeg_g_free (domain_config_file_path);
  }
  <D.19778>:
  info2 = get_per_domain_assembly_binding_info (domain, aname);
  if (info2 != 0B) goto <D.19787>; else goto <D.19788>;
  <D.19787>:
  info = monoeg_g_memdup (info2, 80);
  D.19789 = info2->name;
  D.19790 = monoeg_strdup (D.19789);
  info->name = D.19790;
  D.19791 = info2->culture;
  D.19792 = monoeg_strdup (D.19791);
  info->culture = D.19792;
  D.19793 = domain->domain_id;
  info->domain_id = D.19793;
  <D.19788>:
  {
    int ret;

    D.19741 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.19741);
    if (ret != 0) goto <D.19794>; else goto <D.19795>;
    <D.19794>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19795>:
    D.19796 = ret != 0;
    D.19797 = (long int) D.19796;
    D.19798 = __builtin_expect (D.19797, 0);
    if (D.19798 != 0) goto <D.19799>; else goto <D.19800>;
    <D.19799>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2682, "ret == 0");
    <D.19800>:
  }
  <D.19768>:
  <D.19765>:
  <D.19762>:
  if (info == 0B) goto <D.19801>; else goto <D.19802>;
  <D.19801>:
  info = monoeg_malloc0 (80);
  D.19781 = aname->major;
  D.19782 = (int) D.19781;
  info->major = D.19782;
  D.19783 = aname->minor;
  D.19784 = (int) D.19783;
  info->minor = D.19784;
  <D.19802>:
  D.19803 = BIT_FIELD_REF <*info, 64, 512>;
  D.19804 = D.19803 & 268435456;
  if (D.19804 == 0) goto <D.19805>; else goto <D.19806>;
  <D.19805>:
  ppimage = mono_assembly_load_publisher_policy (aname);
  if (ppimage != 0B) goto <D.19807>; else goto <D.19808>;
  <D.19807>:
  get_publisher_policy_info (ppimage, aname, info);
  mono_image_close (ppimage);
  <D.19808>:
  <D.19806>:
  D.19803 = BIT_FIELD_REF <*info, 64, 512>;
  D.19804 = D.19803 & 268435456;
  if (D.19804 == 0) goto <D.19809>; else goto <D.19810>;
  <D.19809>:
  D.19811 = aname->name;
  D.19812 = monoeg_strdup (D.19811);
  info->name = D.19812;
  D.19813 = aname->culture;
  D.19814 = monoeg_strdup (D.19813);
  info->culture = D.19814;
  D.19815 = &info->public_key_token;
  D.19816 = &aname->public_key_token;
  monoeg_g_strlcpy (D.19815, D.19816, 17);
  <D.19810>:
  mono_assembly_binding_lock ();
  info2 = search_binding_loaded (aname);
  if (info2 != 0B) goto <D.19817>; else goto <D.19818>;
  <D.19817>:
  mono_assembly_binding_info_free (info);
  monoeg_g_free (info);
  info = info2;
  goto <D.19819>;
  <D.19818>:
  loaded_assembly_bindings.72 = loaded_assembly_bindings;
  D.19821 = monoeg_g_slist_prepend (loaded_assembly_bindings.72, info);
  loaded_assembly_bindings = D.19821;
  <D.19819>:
  mono_assembly_binding_unlock ();
  D.19803 = BIT_FIELD_REF <*info, 64, 512>;
  D.19804 = D.19803 & 268435456;
  if (D.19804 == 0) goto <D.19822>; else goto <D.19824>;
  <D.19824>:
  D.19825 = check_policy_versions (info, aname);
  if (D.19825 == 0) goto <D.19822>; else goto <D.19823>;
  <D.19822>:
  D.19738 = aname;
  return D.19738;
  <D.19823>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.19738 = dest_name;
  return D.19738;
}


assembly_binding_info_parsed (struct MonoAssemblyBindingInfo * info, void * user_data)
{
  char * D.19829;
  char * D.19830;
  int D.19831;
  int D.19834;
  struct MonoMemPool * D.19837;
  char * D.19840;
  char * D.19841;
  char * D.19844;
  struct GSList * D.19845;
  struct GSList * D.19846;
  struct MonoAssemblyBindingInfo * info_copy;
  struct GSList * tmp;
  struct MonoAssemblyBindingInfo * info_tmp;
  struct MonoDomain * domain;

  domain = user_data;
  if (domain == 0B) goto <D.19827>; else goto <D.19828>;
  <D.19827>:
  return;
  <D.19828>:
  tmp = domain->assembly_bindings;
  goto <D.18078>;
  <D.18077>:
  info_tmp = tmp->data;
  D.19829 = info->name;
  D.19830 = info_tmp->name;
  D.19831 = strcmp (D.19829, D.19830);
  if (D.19831 == 0) goto <D.19832>; else goto <D.19833>;
  <D.19832>:
  D.19834 = info_versions_equal (info, info_tmp);
  if (D.19834 != 0) goto <D.19835>; else goto <D.19836>;
  <D.19835>:
  return;
  <D.19836>:
  <D.19833>:
  tmp = tmp->next;
  <D.18078>:
  if (tmp != 0B) goto <D.18077>; else goto <D.18079>;
  <D.18079>:
  D.19837 = domain->mp;
  info_copy = mono_mempool_alloc0 (D.19837, 80);
  memcpy (info_copy, info, 80);
  D.19829 = info->name;
  if (D.19829 != 0B) goto <D.19838>; else goto <D.19839>;
  <D.19838>:
  D.19837 = domain->mp;
  D.19829 = info->name;
  D.19840 = mono_mempool_strdup (D.19837, D.19829);
  info_copy->name = D.19840;
  <D.19839>:
  D.19841 = info->culture;
  if (D.19841 != 0B) goto <D.19842>; else goto <D.19843>;
  <D.19842>:
  D.19837 = domain->mp;
  D.19841 = info->culture;
  D.19844 = mono_mempool_strdup (D.19837, D.19841);
  info_copy->culture = D.19844;
  <D.19843>:
  D.19837 = domain->mp;
  D.19845 = domain->assembly_bindings;
  D.19846 = g_slist_append_mempool (D.19837, D.19845, info_copy);
  domain->assembly_bindings = D.19846;
}


info_versions_equal (struct MonoAssemblyBindingInfo * left, struct MonoAssemblyBindingInfo * right)
{
  long unsigned int D.19848;
  long unsigned int D.19849;
  long unsigned int D.19850;
  long unsigned int D.19851;
  gboolean D.19854;
  long unsigned int D.19855;
  long unsigned int D.19858;
  long unsigned int D.19861;
  struct AssemblyVersionSet * D.19864;
  struct AssemblyVersionSet * D.19865;
  int D.19866;
  long unsigned int D.19869;
  struct AssemblyVersionSet * D.19872;
  struct AssemblyVersionSet * D.19873;
  int D.19874;
  long unsigned int D.19877;
  struct AssemblyVersionSet * D.19880;
  struct AssemblyVersionSet * D.19881;
  int D.19882;

  D.19848 = BIT_FIELD_REF <*left, 64, 512>;
  D.19849 = BIT_FIELD_REF <*right, 64, 512>;
  D.19850 = D.19848 ^ D.19849;
  D.19851 = D.19850 & 2147483648;
  if (D.19851 != 0) goto <D.19852>; else goto <D.19853>;
  <D.19852>:
  D.19854 = 0;
  return D.19854;
  <D.19853>:
  D.19848 = BIT_FIELD_REF <*left, 64, 512>;
  D.19849 = BIT_FIELD_REF <*right, 64, 512>;
  D.19850 = D.19848 ^ D.19849;
  D.19855 = D.19850 & 1073741824;
  if (D.19855 != 0) goto <D.19856>; else goto <D.19857>;
  <D.19856>:
  D.19854 = 0;
  return D.19854;
  <D.19857>:
  D.19848 = BIT_FIELD_REF <*left, 64, 512>;
  D.19849 = BIT_FIELD_REF <*right, 64, 512>;
  D.19850 = D.19848 ^ D.19849;
  D.19858 = D.19850 & 536870912;
  if (D.19858 != 0) goto <D.19859>; else goto <D.19860>;
  <D.19859>:
  D.19854 = 0;
  return D.19854;
  <D.19860>:
  D.19848 = BIT_FIELD_REF <*left, 64, 512>;
  D.19861 = D.19848 & 2147483648;
  if (D.19861 != 0) goto <D.19862>; else goto <D.19863>;
  <D.19862>:
  D.19864 = &left->old_version_bottom;
  D.19865 = &right->old_version_bottom;
  D.19866 = info_compare_versions (D.19864, D.19865);
  if (D.19866 == 0) goto <D.19867>; else goto <D.19868>;
  <D.19867>:
  D.19854 = 0;
  return D.19854;
  <D.19868>:
  <D.19863>:
  D.19848 = BIT_FIELD_REF <*left, 64, 512>;
  D.19869 = D.19848 & 1073741824;
  if (D.19869 != 0) goto <D.19870>; else goto <D.19871>;
  <D.19870>:
  D.19872 = &left->old_version_top;
  D.19873 = &right->old_version_top;
  D.19874 = info_compare_versions (D.19872, D.19873);
  if (D.19874 == 0) goto <D.19875>; else goto <D.19876>;
  <D.19875>:
  D.19854 = 0;
  return D.19854;
  <D.19876>:
  <D.19871>:
  D.19848 = BIT_FIELD_REF <*left, 64, 512>;
  D.19877 = D.19848 & 536870912;
  if (D.19877 != 0) goto <D.19878>; else goto <D.19879>;
  <D.19878>:
  D.19880 = &left->new_version;
  D.19881 = &right->new_version;
  D.19882 = info_compare_versions (D.19880, D.19881);
  if (D.19882 == 0) goto <D.19883>; else goto <D.19884>;
  <D.19883>:
  D.19854 = 0;
  return D.19854;
  <D.19884>:
  <D.19879>:
  D.19854 = 1;
  return D.19854;
}


info_compare_versions (struct AssemblyVersionSet * left, struct AssemblyVersionSet * right)
{
  short unsigned int D.19888;
  short unsigned int D.19889;
  short unsigned int D.19891;
  short unsigned int D.19892;
  short unsigned int D.19894;
  short unsigned int D.19895;
  short unsigned int D.19897;
  short unsigned int D.19898;
  gboolean D.19899;

  D.19888 = left->major;
  D.19889 = right->major;
  if (D.19888 != D.19889) goto <D.19886>; else goto <D.19890>;
  <D.19890>:
  D.19891 = left->minor;
  D.19892 = right->minor;
  if (D.19891 != D.19892) goto <D.19886>; else goto <D.19893>;
  <D.19893>:
  D.19894 = left->build;
  D.19895 = right->build;
  if (D.19894 != D.19895) goto <D.19886>; else goto <D.19896>;
  <D.19896>:
  D.19897 = left->revision;
  D.19898 = right->revision;
  if (D.19897 != D.19898) goto <D.19886>; else goto <D.19887>;
  <D.19886>:
  D.19899 = 0;
  return D.19899;
  <D.19887>:
  D.19899 = 1;
  return D.19899;
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.19903;
  struct GSList * D.19904;
  struct GSList * new_list;
  struct GSList * last;

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.19901>; else goto <D.19902>;
  <D.19901>:
  last = list;
  goto <D.10992>;
  <D.10991>:
  last = last->next;
  <D.10992>:
  D.19903 = last->next;
  if (D.19903 != 0B) goto <D.10991>; else goto <D.10993>;
  <D.10993>:
  last->next = new_list;
  D.19904 = list;
  return D.19904;
  <D.19902>:
  D.19904 = new_list;
  return D.19904;
}


get_per_domain_assembly_binding_info (struct MonoDomain * domain, struct MonoAssemblyName * aname)
{
  struct GSList * D.19906;
  struct MonoAssemblyBindingInfo * D.19909;
  const char * D.19912;
  char * D.19913;
  int D.19914;
  int D.19917;
  unsigned char D.19924;
  long unsigned int D.19926;
  long unsigned int D.19927;
  int D.19929;
  struct MonoAssemblyBindingInfo * info;
  struct GSList * list;

  D.19906 = domain->assembly_bindings;
  if (D.19906 == 0B) goto <D.19907>; else goto <D.19908>;
  <D.19907>:
  D.19909 = 0B;
  return D.19909;
  <D.19908>:
  info = 0B;
  list = domain->assembly_bindings;
  goto <D.18097>;
  <D.18096>:
  info = list->data;
  if (info != 0B) goto <D.19910>; else goto <D.19911>;
  <D.19910>:
  D.19912 = aname->name;
  D.19913 = info->name;
  D.19914 = strcmp (D.19912, D.19913);
  if (D.19914 == 0) goto <D.19915>; else goto <D.19916>;
  <D.19915>:
  D.19917 = info_major_minor_in_range (info, aname);
  if (D.19917 != 0) goto <D.18095>; else goto <D.19918>;
  <D.19918>:
  <D.19916>:
  <D.19911>:
  info = 0B;
  list = list->next;
  <D.18097>:
  if (list != 0B) goto <D.18096>; else goto <D.18095>;
  <D.18095>:
  if (info != 0B) goto <D.19919>; else goto <D.19920>;
  <D.19919>:
  D.19913 = info->name;
  if (D.19913 != 0B) goto <D.19923>; else goto <D.19921>;
  <D.19923>:
  D.19924 = info->public_key_token[0];
  if (D.19924 != 0) goto <D.19925>; else goto <D.19921>;
  <D.19925>:
  D.19926 = BIT_FIELD_REF <*info, 64, 512>;
  D.19927 = D.19926 & 2684354560;
  if (D.19927 == 2684354560) goto <D.19928>; else goto <D.19921>;
  <D.19928>:
  D.19929 = assembly_binding_maps_name (info, aname);
  if (D.19929 != 0) goto <D.19930>; else goto <D.19921>;
  <D.19930>:
  info->is_valid = 1;
  goto <D.19922>;
  <D.19921>:
  info->is_valid = 0;
  <D.19922>:
  <D.19920>:
  D.19909 = info;
  return D.19909;
}


info_major_minor_in_range (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  short unsigned int D.19932;
  int D.19933;
  short unsigned int D.19934;
  int D.19935;
  long unsigned int D.19936;
  long unsigned int D.19937;
  gboolean D.19940;
  short unsigned int D.19941;
  int D.19942;
  short unsigned int D.19943;
  int D.19944;
  int D.19945;
  long unsigned int D.19948;
  short unsigned int D.19951;
  int D.19952;
  short unsigned int D.19953;
  int D.19954;
  int D.19955;
  int aname_version_number;

  D.19932 = aname->major;
  D.19933 = (int) D.19932;
  D.19934 = aname->minor;
  D.19935 = (int) D.19934;
  aname_version_number = get_version_number (D.19933, D.19935);
  D.19936 = BIT_FIELD_REF <*info, 64, 512>;
  D.19937 = D.19936 & 2147483648;
  if (D.19937 == 0) goto <D.19938>; else goto <D.19939>;
  <D.19938>:
  D.19940 = 0;
  return D.19940;
  <D.19939>:
  D.19941 = info->old_version_bottom.major;
  D.19942 = (int) D.19941;
  D.19943 = info->old_version_bottom.minor;
  D.19944 = (int) D.19943;
  D.19945 = get_version_number (D.19942, D.19944);
  if (D.19945 > aname_version_number) goto <D.19946>; else goto <D.19947>;
  <D.19946>:
  D.19940 = 0;
  return D.19940;
  <D.19947>:
  D.19936 = BIT_FIELD_REF <*info, 64, 512>;
  D.19948 = D.19936 & 1073741824;
  if (D.19948 != 0) goto <D.19949>; else goto <D.19950>;
  <D.19949>:
  D.19951 = info->old_version_top.major;
  D.19952 = (int) D.19951;
  D.19953 = info->old_version_top.minor;
  D.19954 = (int) D.19953;
  D.19955 = get_version_number (D.19952, D.19954);
  if (D.19955 < aname_version_number) goto <D.19956>; else goto <D.19957>;
  <D.19956>:
  D.19940 = 0;
  return D.19940;
  <D.19957>:
  <D.19950>:
  D.19932 = aname->major;
  D.19933 = (int) D.19932;
  info->major = D.19933;
  D.19934 = aname->minor;
  D.19935 = (int) D.19934;
  info->minor = D.19935;
  D.19940 = 1;
  return D.19940;
}


get_version_number (int major, int minor)
{
  int D.19959;
  int D.19960;

  D.19960 = major * 256;
  D.19959 = D.19960 + minor;
  return D.19959;
}


assembly_binding_maps_name (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  char * D.19965;
  gboolean D.19966;
  const char * D.19967;
  int D.19968;
  int D.19973;
  short unsigned int D.19974;
  int D.19975;
  int D.19977;
  short unsigned int D.19978;
  int D.19979;
  int iftmp.73;
  char * D.19983;
  char D.19985;
  _Bool D.19987;
  int iftmp.74;
  const char * D.19991;
  char D.19993;
  _Bool D.19995;
  _Bool D.19996;
  int D.20003;
  guchar[17] * D.20006;
  mono_byte[17] * D.20007;
  int D.20008;

  if (info == 0B) goto <D.19962>; else goto <D.19964>;
  <D.19964>:
  D.19965 = info->name;
  if (D.19965 == 0B) goto <D.19962>; else goto <D.19963>;
  <D.19962>:
  D.19966 = 0;
  return D.19966;
  <D.19963>:
  D.19965 = info->name;
  D.19967 = aname->name;
  D.19968 = strcmp (D.19965, D.19967);
  if (D.19968 != 0) goto <D.19969>; else goto <D.19970>;
  <D.19969>:
  D.19966 = 0;
  return D.19966;
  <D.19970>:
  D.19973 = info->major;
  D.19974 = aname->major;
  D.19975 = (int) D.19974;
  if (D.19973 != D.19975) goto <D.19971>; else goto <D.19976>;
  <D.19976>:
  D.19977 = info->minor;
  D.19978 = aname->minor;
  D.19979 = (int) D.19978;
  if (D.19977 != D.19979) goto <D.19971>; else goto <D.19972>;
  <D.19971>:
  D.19966 = 0;
  return D.19966;
  <D.19972>:
  D.19983 = info->culture;
  if (D.19983 != 0B) goto <D.19984>; else goto <D.19981>;
  <D.19984>:
  D.19983 = info->culture;
  D.19985 = *D.19983;
  if (D.19985 != 0) goto <D.19986>; else goto <D.19981>;
  <D.19986>:
  iftmp.73 = 1;
  goto <D.19982>;
  <D.19981>:
  iftmp.73 = 0;
  <D.19982>:
  D.19987 = (_Bool) iftmp.73;
  D.19991 = aname->culture;
  if (D.19991 != 0B) goto <D.19992>; else goto <D.19989>;
  <D.19992>:
  D.19991 = aname->culture;
  D.19993 = *D.19991;
  if (D.19993 != 0) goto <D.19994>; else goto <D.19989>;
  <D.19994>:
  iftmp.74 = 1;
  goto <D.19990>;
  <D.19989>:
  iftmp.74 = 0;
  <D.19990>:
  D.19995 = (_Bool) iftmp.74;
  D.19996 = D.19987 ^ D.19995;
  if (D.19996 != 0) goto <D.19997>; else goto <D.19998>;
  <D.19997>:
  D.19966 = 0;
  return D.19966;
  <D.19998>:
  D.19983 = info->culture;
  if (D.19983 != 0B) goto <D.19999>; else goto <D.20000>;
  <D.19999>:
  D.19991 = aname->culture;
  if (D.19991 != 0B) goto <D.20001>; else goto <D.20002>;
  <D.20001>:
  D.19983 = info->culture;
  D.19991 = aname->culture;
  D.20003 = strcmp (D.19983, D.19991);
  if (D.20003 != 0) goto <D.20004>; else goto <D.20005>;
  <D.20004>:
  D.19966 = 0;
  return D.19966;
  <D.20005>:
  <D.20002>:
  <D.20000>:
  D.20006 = &info->public_key_token;
  D.20007 = &aname->public_key_token;
  D.20008 = mono_public_tokens_are_equal (D.20006, D.20007);
  if (D.20008 == 0) goto <D.20009>; else goto <D.20010>;
  <D.20009>:
  D.19966 = 0;
  return D.19966;
  <D.20010>:
  D.19966 = 1;
  return D.19966;
}


mono_assembly_load_publisher_policy (struct MonoAssemblyName * aname)
{
  const char * D.20012;
  char * D.20013;
  long unsigned int D.20016;
  unsigned int D.20017;
  unsigned int D.20018;
  long unsigned int D.20019;
  long unsigned int D.20020;
  const char * D.20022;
  short unsigned int D.20026;
  int D.20027;
  short unsigned int D.20028;
  int D.20029;
  mono_byte[17] * D.20030;
  char * * extra_gac_paths.75;
  gchar * D.20034;
  struct MonoImage * D.20038;
  const char * D.20039;
  struct MonoImage * image;
  gchar * filename;
  gchar * pname;
  gchar * name;
  gchar * culture;
  gchar * version;
  gchar * fullpath;
  gchar * subpath;
  gchar * * paths;
  gint32 len;

  D.20012 = aname->name;
  D.20013 = strstr (D.20012, ".dll");
  if (D.20013 != 0B) goto <D.20014>; else goto <D.20015>;
  <D.20014>:
  D.20012 = aname->name;
  D.20016 = __strlen_g (D.20012);
  D.20017 = (unsigned int) D.20016;
  D.20018 = D.20017 + 4294967292;
  len = (gint32) D.20018;
  D.20019 = (long unsigned int) len;
  name = monoeg_malloc (D.20019);
  D.20012 = aname->name;
  D.20020 = (long unsigned int) len;
  strncpy (name, D.20012, D.20020);
  goto <D.20021>;
  <D.20015>:
  D.20012 = aname->name;
  name = monoeg_strdup (D.20012);
  <D.20021>:
  D.20022 = aname->culture;
  if (D.20022 != 0B) goto <D.20023>; else goto <D.20024>;
  <D.20023>:
  D.20022 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.20022, -1);
  goto <D.20025>;
  <D.20024>:
  culture = monoeg_strdup ("");
  <D.20025>:
  D.20026 = aname->major;
  D.20027 = (int) D.20026;
  D.20028 = aname->minor;
  D.20029 = (int) D.20028;
  pname = monoeg_g_strdup_printf ("policy.%d.%d.%s", D.20027, D.20029, name);
  D.20030 = &aname->public_key_token;
  version = monoeg_g_strdup_printf ("0.0.0.0_%s_%s", culture, D.20030);
  monoeg_g_free (name);
  monoeg_g_free (culture);
  filename = monoeg_g_strconcat (pname, ".dll", 0B);
  subpath = monoeg_g_build_path ("/", pname, version, filename, 0B);
  monoeg_g_free (pname);
  monoeg_g_free (version);
  monoeg_g_free (filename);
  image = 0B;
  extra_gac_paths.75 = extra_gac_paths;
  if (extra_gac_paths.75 != 0B) goto <D.20032>; else goto <D.20033>;
  <D.20032>:
  paths = extra_gac_paths;
  goto <D.18046>;
  <D.18045>:
  D.20034 = *paths;
  fullpath = monoeg_g_build_path ("/", D.20034, "lib", "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (fullpath);
  paths = paths + 8;
  <D.18046>:
  if (image == 0B) goto <D.20035>; else goto <D.18047>;
  <D.20035>:
  D.20034 = *paths;
  if (D.20034 != 0B) goto <D.18045>; else goto <D.18047>;
  <D.18047>:
  <D.20033>:
  if (image != 0B) goto <D.20036>; else goto <D.20037>;
  <D.20036>:
  monoeg_g_free (subpath);
  D.20038 = image;
  return D.20038;
  <D.20037>:
  D.20039 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.20039, "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (subpath);
  monoeg_g_free (fullpath);
  D.20038 = image;
  return D.20038;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.20041;
  long unsigned int D.20042;

  D.20042 = __builtin_object_size (__dest, 1);
  D.20041 = __builtin___strncpy_chk (__dest, __src, __len, D.20042);
  return D.20041;
}


get_publisher_policy_info (struct MonoImage * image, struct MonoAssemblyName * aname, struct MonoAssemblyBindingInfo * binding_info)
{
  <unnamed-unsigned:24> D.20044;
  int D.20045;
  unsigned int D.20048;
  unsigned int D.20049;
  unsigned int D.20052;
  _Bool D.20053;
  long int D.20054;
  long int D.20055;
  char * D.20058;
  char * D.20059;
  gchar * D.20062;
  char * D.20065;
  unsigned char D.20067;
  long unsigned int D.20069;
  long unsigned int D.20070;
  int D.20072;
  struct MonoTableInfo * t;
  guint32 cols[4];
  const gchar * filename;
  gchar * subpath;
  gchar * fullpath;

  try
    {
      t = &image->tables[40];
      D.20044 = t->rows;
      D.20045 = (int) D.20044;
      if (D.20045 <= 0) goto <D.20046>; else goto <D.20047>;
      <D.20046>:
      binding_info->is_valid = 0;
      return;
      <D.20047>:
      mono_metadata_decode_row (t, 0, &cols, 4);
      D.20048 = cols[3];
      D.20049 = D.20048 & 3;
      if (D.20049 != 0) goto <D.20050>; else goto <D.20051>;
      <D.20050>:
      binding_info->is_valid = 0;
      return;
      <D.20051>:
      D.20052 = cols[2];
      filename = mono_metadata_string_heap (image, D.20052);
      D.20053 = filename == 0B;
      D.20054 = (long int) D.20053;
      D.20055 = __builtin_expect (D.20054, 0);
      if (D.20055 != 0) goto <D.20056>; else goto <D.20057>;
      <D.20056>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 370, "filename != NULL");
      <D.20057>:
      D.20058 = image->name;
      subpath = monoeg_g_path_get_dirname (D.20058);
      fullpath = monoeg_g_build_path ("/", subpath, filename, 0B);
      mono_config_parse_publisher_policy (fullpath, binding_info);
      monoeg_g_free (subpath);
      monoeg_g_free (fullpath);
      D.20059 = binding_info->culture;
      if (D.20059 == 0B) goto <D.20060>; else goto <D.20061>;
      <D.20060>:
      D.20062 = monoeg_strdup ("");
      binding_info->culture = D.20062;
      <D.20061>:
      D.20065 = binding_info->name;
      if (D.20065 == 0B) goto <D.20063>; else goto <D.20066>;
      <D.20066>:
      D.20067 = binding_info->public_key_token[0];
      if (D.20067 == 0) goto <D.20063>; else goto <D.20068>;
      <D.20068>:
      D.20069 = BIT_FIELD_REF <*binding_info, 64, 512>;
      D.20070 = D.20069 & 2684354560;
      if (D.20070 != 2684354560) goto <D.20063>; else goto <D.20071>;
      <D.20071>:
      D.20072 = assembly_binding_maps_name (binding_info, aname);
      if (D.20072 == 0) goto <D.20063>; else goto <D.20064>;
      <D.20063>:
      mono_assembly_binding_info_free (binding_info);
      binding_info->is_valid = 0;
      return;
      <D.20064>:
      binding_info->is_valid = 1;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_assembly_binding_lock ()
{
  pthread_mutex_lock (&assembly_binding_mutex);
}


search_binding_loaded (struct MonoAssemblyName * aname)
{
  int D.20076;
  struct MonoAssemblyBindingInfo * D.20079;
  struct GSList * tmp;

  tmp = loaded_assembly_bindings;
  goto <D.18059>;
  <D.18058>:
  {
    struct MonoAssemblyBindingInfo * info;

    info = tmp->data;
    D.20076 = assembly_binding_maps_name (info, aname);
    if (D.20076 != 0) goto <D.20077>; else goto <D.20078>;
    <D.20077>:
    D.20079 = info;
    return D.20079;
    <D.20078>:
  }
  tmp = tmp->next;
  <D.18059>:
  if (tmp != 0B) goto <D.18058>; else goto <D.18060>;
  <D.18060>:
  D.20079 = 0B;
  return D.20079;
}


mono_assembly_binding_info_free (struct MonoAssemblyBindingInfo * info)
{
  char * D.20083;
  char * D.20084;

  if (info == 0B) goto <D.20081>; else goto <D.20082>;
  <D.20081>:
  return;
  <D.20082>:
  D.20083 = info->name;
  monoeg_g_free (D.20083);
  D.20084 = info->culture;
  monoeg_g_free (D.20084);
}


mono_assembly_binding_unlock ()
{
  pthread_mutex_unlock (&assembly_binding_mutex);
}


check_policy_versions (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * name)
{
  long unsigned int D.20086;
  long unsigned int D.20087;
  gboolean D.20090;
  long unsigned int D.20091;
  struct AssemblyVersionSet * D.20094;
  int D.20095;
  struct AssemblyVersionSet * D.20098;
  int D.20099;
  int D.20102;

  D.20086 = BIT_FIELD_REF <*info, 64, 512>;
  D.20087 = D.20086 & 268435456;
  if (D.20087 == 0) goto <D.20088>; else goto <D.20089>;
  <D.20088>:
  D.20090 = 0;
  return D.20090;
  <D.20089>:
  D.20086 = BIT_FIELD_REF <*info, 64, 512>;
  D.20091 = D.20086 & 1073741824;
  if (D.20091 == 0) goto <D.20092>; else goto <D.20093>;
  <D.20092>:
  D.20094 = &info->old_version_bottom;
  D.20095 = compare_versions (D.20094, name);
  if (D.20095 == 0) goto <D.20096>; else goto <D.20097>;
  <D.20096>:
  D.20090 = 1;
  return D.20090;
  <D.20097>:
  D.20090 = 0;
  return D.20090;
  <D.20093>:
  D.20098 = &info->old_version_top;
  D.20099 = compare_versions (D.20098, name);
  if (D.20099 < 0) goto <D.20100>; else goto <D.20101>;
  <D.20100>:
  D.20090 = 0;
  return D.20090;
  <D.20101>:
  D.20094 = &info->old_version_bottom;
  D.20102 = compare_versions (D.20094, name);
  if (D.20102 > 0) goto <D.20103>; else goto <D.20104>;
  <D.20103>:
  D.20090 = 0;
  return D.20090;
  <D.20104>:
  D.20090 = 1;
  return D.20090;
}


compare_versions (struct AssemblyVersionSet * v, struct MonoAssemblyName * aname)
{
  short unsigned int D.20106;
  short unsigned int D.20107;
  int D.20110;
  short unsigned int D.20113;
  short unsigned int D.20114;
  short unsigned int D.20119;
  short unsigned int D.20120;
  short unsigned int D.20125;
  short unsigned int D.20126;

  D.20106 = v->major;
  D.20107 = aname->major;
  if (D.20106 > D.20107) goto <D.20108>; else goto <D.20109>;
  <D.20108>:
  D.20110 = 1;
  return D.20110;
  <D.20109>:
  D.20106 = v->major;
  D.20107 = aname->major;
  if (D.20106 < D.20107) goto <D.20111>; else goto <D.20112>;
  <D.20111>:
  D.20110 = -1;
  return D.20110;
  <D.20112>:
  D.20113 = v->minor;
  D.20114 = aname->minor;
  if (D.20113 > D.20114) goto <D.20115>; else goto <D.20116>;
  <D.20115>:
  D.20110 = 1;
  return D.20110;
  <D.20116>:
  D.20113 = v->minor;
  D.20114 = aname->minor;
  if (D.20113 < D.20114) goto <D.20117>; else goto <D.20118>;
  <D.20117>:
  D.20110 = -1;
  return D.20110;
  <D.20118>:
  D.20119 = v->build;
  D.20120 = aname->build;
  if (D.20119 > D.20120) goto <D.20121>; else goto <D.20122>;
  <D.20121>:
  D.20110 = 1;
  return D.20110;
  <D.20122>:
  D.20119 = v->build;
  D.20120 = aname->build;
  if (D.20119 < D.20120) goto <D.20123>; else goto <D.20124>;
  <D.20123>:
  D.20110 = -1;
  return D.20110;
  <D.20124>:
  D.20125 = v->revision;
  D.20126 = aname->revision;
  if (D.20125 > D.20126) goto <D.20127>; else goto <D.20128>;
  <D.20127>:
  D.20110 = 1;
  return D.20110;
  <D.20128>:
  D.20125 = v->revision;
  D.20126 = aname->revision;
  if (D.20125 < D.20126) goto <D.20129>; else goto <D.20130>;
  <D.20129>:
  D.20110 = -1;
  return D.20110;
  <D.20130>:
  D.20110 = 0;
  return D.20110;
}


mono_assembly_bind_version (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  short unsigned int D.20132;
  short unsigned int D.20133;
  short unsigned int D.20134;
  short unsigned int D.20135;
  struct MonoAssemblyName * D.20136;

  memcpy (dest_name, aname, 80);
  D.20132 = info->new_version.major;
  dest_name->major = D.20132;
  D.20133 = info->new_version.minor;
  dest_name->minor = D.20133;
  D.20134 = info->new_version.build;
  dest_name->build = D.20134;
  D.20135 = info->new_version.revision;
  dest_name->revision = D.20135;
  D.20136 = dest_name;
  return D.20136;
}


invoke_assembly_refonly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<T1040>) (struct MonoAssemblyName *, char * *, void *) D.20138;
  void * D.20139;
  struct MonoAssembly * D.20142;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_refonly_preload_hook;
  goto <D.17753>;
  <D.17752>:
  D.20138 = hook->func;
  D.20139 = hook->user_data;
  assembly = D.20138 (aname, assemblies_path, D.20139);
  if (assembly != 0B) goto <D.20140>; else goto <D.20141>;
  <D.20140>:
  D.20142 = assembly;
  return D.20142;
  <D.20141>:
  hook = hook->next;
  <D.17753>:
  if (hook != 0B) goto <D.17752>; else goto <D.17754>;
  <D.17754>:
  D.20142 = 0B;
  return D.20142;
}


mono_assembly_load_from_gac (struct MonoAssemblyName * aname, gchar * filename, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  unsigned char D.20144;
  struct MonoAssembly * D.20147;
  const char * D.20148;
  char * D.20149;
  long unsigned int D.20152;
  unsigned int D.20153;
  unsigned int D.20154;
  long unsigned int D.20155;
  long unsigned int D.20156;
  const char * D.20158;
  mono_byte[17] * D.20162;
  short unsigned int D.20163;
  int D.20164;
  short unsigned int D.20165;
  int D.20166;
  short unsigned int D.20167;
  int D.20168;
  short unsigned int D.20169;
  int D.20170;
  char * * extra_gac_paths.76;
  gchar * D.20174;
  int D.20175;
  const char * D.20179;
  struct MonoAssembly * result;
  gchar * name;
  gchar * version;
  gchar * culture;
  gchar * fullpath;
  gchar * subpath;
  gint32 len;
  gchar * * paths;
  char * pubtok;

  result = 0B;
  D.20144 = aname->public_key_token[0];
  if (D.20144 == 0) goto <D.20145>; else goto <D.20146>;
  <D.20145>:
  D.20147 = 0B;
  return D.20147;
  <D.20146>:
  D.20148 = aname->name;
  D.20149 = strstr (D.20148, ".dll");
  if (D.20149 != 0B) goto <D.20150>; else goto <D.20151>;
  <D.20150>:
  D.20152 = __strlen_g (filename);
  D.20153 = (unsigned int) D.20152;
  D.20154 = D.20153 + 4294967292;
  len = (gint32) D.20154;
  D.20155 = (long unsigned int) len;
  name = monoeg_malloc (D.20155);
  D.20148 = aname->name;
  D.20156 = (long unsigned int) len;
  strncpy (name, D.20148, D.20156);
  goto <D.20157>;
  <D.20151>:
  D.20148 = aname->name;
  name = monoeg_strdup (D.20148);
  <D.20157>:
  D.20158 = aname->culture;
  if (D.20158 != 0B) goto <D.20159>; else goto <D.20160>;
  <D.20159>:
  D.20158 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.20158, -1);
  goto <D.20161>;
  <D.20160>:
  culture = monoeg_strdup ("");
  <D.20161>:
  D.20162 = &aname->public_key_token;
  pubtok = monoeg_g_ascii_strdown (D.20162, 17);
  D.20163 = aname->major;
  D.20164 = (int) D.20163;
  D.20165 = aname->minor;
  D.20166 = (int) D.20165;
  D.20167 = aname->build;
  D.20168 = (int) D.20167;
  D.20169 = aname->revision;
  D.20170 = (int) D.20169;
  version = monoeg_g_strdup_printf ("%d.%d.%d.%d_%s_%s", D.20164, D.20166, D.20168, D.20170, culture, pubtok);
  monoeg_g_free (pubtok);
  subpath = monoeg_g_build_path ("/", name, version, filename, 0B);
  monoeg_g_free (name);
  monoeg_g_free (version);
  monoeg_g_free (culture);
  extra_gac_paths.76 = extra_gac_paths;
  if (extra_gac_paths.76 != 0B) goto <D.20172>; else goto <D.20173>;
  <D.20172>:
  paths = extra_gac_paths;
  goto <D.18128>;
  <D.18127>:
  D.20174 = *paths;
  fullpath = monoeg_g_build_path ("/", D.20174, "lib", "mono", "gac", subpath, 0B);
  D.20175 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.20175);
  monoeg_g_free (fullpath);
  paths = paths + 8;
  <D.18128>:
  if (result == 0B) goto <D.20176>; else goto <D.18129>;
  <D.20176>:
  D.20174 = *paths;
  if (D.20174 != 0B) goto <D.18127>; else goto <D.18129>;
  <D.18129>:
  <D.20173>:
  if (result != 0B) goto <D.20177>; else goto <D.20178>;
  <D.20177>:
  result->in_gac = 1;
  monoeg_g_free (subpath);
  D.20147 = result;
  return D.20147;
  <D.20178>:
  D.20179 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.20179, "mono", "gac", subpath, 0B);
  D.20175 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.20175);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.20180>; else goto <D.20181>;
  <D.20180>:
  result->in_gac = 1;
  <D.20181>:
  monoeg_g_free (subpath);
  D.20147 = result;
  return D.20147;
}


mono_assembly_load_full (struct MonoAssemblyName * aname, const char * basedir, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.20185;
  struct MonoAssembly * result;

  result = mono_assembly_load_full_nosearch (aname, basedir, status, refonly);
  if (result == 0B) goto <D.20183>; else goto <D.20184>;
  <D.20183>:
  result = mono_assembly_invoke_search_hook_internal (aname, refonly, 1);
  <D.20184>:
  D.20185 = result;
  return D.20185;
}


mono_assembly_load (struct MonoAssemblyName * aname, const char * basedir, MonoImageOpenStatus * status)
{
  struct MonoAssembly * D.20187;

  D.20187 = mono_assembly_load_full (aname, basedir, status, 0);
  return D.20187;
}


mono_assembly_loaded_full (struct MonoAssemblyName * aname, gboolean refonly)
{
  struct MonoAssembly * D.20189;
  struct MonoAssembly * res;
  struct MonoAssemblyName maped_aname;

  try
    {
      aname = mono_assembly_remap_version (aname, &maped_aname);
      res = mono_assembly_invoke_search_hook_internal (aname, refonly, 0);
      D.20189 = res;
      return D.20189;
    }
  finally
    {
      maped_aname = {CLOBBER};
    }
}


mono_assembly_loaded (struct MonoAssemblyName * aname)
{
  struct MonoAssembly * D.20192;

  D.20192 = mono_assembly_loaded_full (aname, 0);
  return D.20192;
}


__attribute__((visibility ("hidden")))
mono_assembly_release_gc_roots (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.20194;
  unsigned char D.20197;
  struct MonoImage * * D.20200;
  long unsigned int D.20201;
  long unsigned int D.20202;
  struct MonoImage * * D.20203;
  struct MonoImage * D.20204;
  unsigned int D.20205;
  unsigned int i.77;

  D.20194 = assembly + 18446744073709551615;
  if (D.20194 > -3B) goto <D.20195>; else goto <D.20196>;
  <D.20195>:
  return;
  <D.20196>:
  D.20197 = assembly->dynamic;
  if (D.20197 != 0) goto <D.20198>; else goto <D.20199>;
  <D.20198>:
  {
    int i;
    struct MonoDynamicImage * dynimg;

    dynimg = assembly->image;
    i = 0;
    goto <D.18180>;
    <D.18179>:
    D.20200 = dynimg->image.modules;
    D.20201 = (long unsigned int) i;
    D.20202 = D.20201 * 8;
    D.20203 = D.20200 + D.20202;
    D.20204 = *D.20203;
    mono_dynamic_image_release_gc_roots (D.20204);
    i = i + 1;
    <D.18180>:
    D.20205 = dynimg->image.module_count;
    i.77 = (unsigned int) i;
    if (D.20205 > i.77) goto <D.18179>; else goto <D.18181>;
    <D.18181>:
    mono_dynamic_image_release_gc_roots (dynimg);
  }
  <D.20199>:
}


__attribute__((visibility ("hidden")))
mono_assembly_close_except_image_pools (struct MonoAssembly * assembly)
{
  gboolean D.20210;
  int * D.20213;
  int D.20214;
  const char * D.20217;
  struct MonoImage * D.20218;
  _Bool D.20221;
  long int D.20222;
  long int D.20223;
  struct GList * loaded_assemblies.78;
  struct GList * D.20227;
  _Bool D.20230;
  long int D.20231;
  long int D.20232;
  int D.20235;
  struct GSList * D.20238;
  char * D.20239;
  struct GSList * tmp;

  if (assembly == 0B) goto <D.20208>; else goto <D.20209>;
  <D.20208>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 3029, "assembly != NULL");
  D.20210 = 0;
  return D.20210;
  <D.20209>:
  if (assembly == -1B) goto <D.20211>; else goto <D.20212>;
  <D.20211>:
  D.20210 = 0;
  return D.20210;
  <D.20212>:
  D.20213 = &assembly->ref_count;
  D.20214 = InterlockedDecrement (D.20213);
  if (D.20214 > 0) goto <D.20215>; else goto <D.20216>;
  <D.20215>:
  D.20210 = 0;
  return D.20210;
  <D.20216>:
  mono_profiler_assembly_event (assembly, 2);
  D.20217 = assembly->aname.name;
  mono_trace (64, 1, "Unloading assembly %s [%p].", D.20217, assembly);
  D.20218 = assembly->image;
  mono_debug_close_image (D.20218);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20219>; else goto <D.20220>;
    <D.20219>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20220>:
    D.20221 = ret != 0;
    D.20222 = (long int) D.20221;
    D.20223 = __builtin_expect (D.20222, 0);
    if (D.20223 != 0) goto <D.20224>; else goto <D.20225>;
    <D.20224>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3044, "ret == 0");
    <D.20225>:
  }
  loaded_assemblies.78 = loaded_assemblies;
  D.20227 = monoeg_g_list_remove (loaded_assemblies.78, assembly);
  loaded_assemblies = D.20227;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20228>; else goto <D.20229>;
    <D.20228>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20229>:
    D.20230 = ret != 0;
    D.20231 = (long int) D.20230;
    D.20232 = __builtin_expect (D.20231, 0);
    if (D.20232 != 0) goto <D.20233>; else goto <D.20234>;
    <D.20233>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3046, "ret == 0");
    <D.20234>:
  }
  D.20218 = assembly->image;
  D.20218->assembly = 0B;
  D.20218 = assembly->image;
  D.20235 = mono_image_close_except_pools (D.20218);
  if (D.20235 == 0) goto <D.20236>; else goto <D.20237>;
  <D.20236>:
  assembly->image = 0B;
  <D.20237>:
  tmp = assembly->friend_assembly_names;
  goto <D.18190>;
  <D.18189>:
  {
    struct MonoAssemblyName * fname;

    fname = tmp->data;
    mono_assembly_name_free (fname);
    monoeg_g_free (fname);
  }
  tmp = tmp->next;
  <D.18190>:
  if (tmp != 0B) goto <D.18189>; else goto <D.18191>;
  <D.18191>:
  D.20238 = assembly->friend_assembly_names;
  monoeg_g_slist_free (D.20238);
  D.20239 = assembly->basedir;
  monoeg_g_free (D.20239);
  mono_profiler_assembly_event (assembly, 3);
  D.20210 = 1;
  return D.20210;
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.20241;
  unsigned int D.20242;

  D.20242 = __sync_sub_and_fetch_4 (val, 1);
  D.20241 = (gint32) D.20242;
  return D.20241;
}


__attribute__((visibility ("hidden")))
mono_assembly_close_finish (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.20244;
  _Bool D.20245;
  long int D.20246;
  long int D.20247;
  struct MonoImage * D.20250;
  unsigned char D.20253;
  const char * D.20256;

  D.20244 = assembly + 18446744073709551615;
  D.20245 = D.20244 > -3B;
  D.20246 = (long int) D.20245;
  D.20247 = __builtin_expect (D.20246, 0);
  if (D.20247 != 0) goto <D.20248>; else goto <D.20249>;
  <D.20248>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3069, "assembly && assembly != REFERENCE_MISSING");
  <D.20249>:
  D.20250 = assembly->image;
  if (D.20250 != 0B) goto <D.20251>; else goto <D.20252>;
  <D.20251>:
  D.20250 = assembly->image;
  mono_image_close_finish (D.20250);
  <D.20252>:
  D.20253 = assembly->dynamic;
  if (D.20253 != 0) goto <D.20254>; else goto <D.20255>;
  <D.20254>:
  D.20256 = assembly->aname.culture;
  monoeg_g_free (D.20256);
  goto <D.20257>;
  <D.20255>:
  monoeg_g_free (assembly);
  <D.20257>:
}


mono_assembly_close (struct MonoAssembly * assembly)
{
  int D.20258;

  D.20258 = mono_assembly_close_except_image_pools (assembly);
  if (D.20258 != 0) goto <D.20259>; else goto <D.20260>;
  <D.20259>:
  mono_assembly_close_finish (assembly);
  <D.20260>:
}


mono_assembly_load_module (struct MonoAssembly * assembly, guint32 idx)
{
  struct MonoImage * D.20261;
  struct MonoImage * D.20262;
  int idx.79;

  D.20262 = assembly->image;
  idx.79 = (int) idx;
  D.20261 = mono_image_load_file_for_image (D.20262, idx.79);
  return D.20261;
}


mono_assembly_foreach (void (*GFunc) (void *, void *) func, void * user_data)
{
  _Bool D.20267;
  long int D.20268;
  long int D.20269;
  struct GList * loaded_assemblies.80;
  _Bool D.20275;
  long int D.20276;
  long int D.20277;
  struct GList * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20265>; else goto <D.20266>;
    <D.20265>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20266>:
    D.20267 = ret != 0;
    D.20268 = (long int) D.20267;
    D.20269 = __builtin_expect (D.20268, 0);
    if (D.20269 != 0) goto <D.20270>; else goto <D.20271>;
    <D.20270>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3110, "ret == 0");
    <D.20271>:
  }
  loaded_assemblies.80 = loaded_assemblies;
  copy = monoeg_g_list_copy (loaded_assemblies.80);
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20273>; else goto <D.20274>;
    <D.20273>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20274>:
    D.20275 = ret != 0;
    D.20276 = (long int) D.20275;
    D.20277 = __builtin_expect (D.20276, 0);
    if (D.20277 != 0) goto <D.20278>; else goto <D.20279>;
    <D.20278>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3112, "ret == 0");
    <D.20279>:
  }
  loaded_assemblies.80 = loaded_assemblies;
  monoeg_g_list_foreach (loaded_assemblies.80, func, user_data);
  monoeg_g_list_free (copy);
}


mono_assemblies_cleanup ()
{
  struct GSList * loaded_assembly_bindings.81;
  struct GSList * l;

  DeleteCriticalSection (&assemblies_mutex);
  pthread_mutex_destroy (&assembly_binding_mutex);
  l = loaded_assembly_bindings;
  goto <D.18215>;
  <D.18214>:
  {
    struct MonoAssemblyBindingInfo * info;

    info = l->data;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
  }
  l = l->next;
  <D.18215>:
  if (l != 0B) goto <D.18214>; else goto <D.18216>;
  <D.18216>:
  loaded_assembly_bindings.81 = loaded_assembly_bindings;
  monoeg_g_slist_free (loaded_assembly_bindings.81);
  free_assembly_load_hooks ();
  free_assembly_search_hooks ();
  free_assembly_preload_hooks ();
}


free_assembly_load_hooks ()
{
  struct AssemblyLoadHook * hook;
  struct AssemblyLoadHook * next;

  hook = assembly_load_hook;
  goto <D.17676>;
  <D.17675>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17676>:
  if (hook != 0B) goto <D.17675>; else goto <D.17677>;
  <D.17677>:
}


free_assembly_search_hooks ()
{
  struct AssemblySearchHook * hook;
  struct AssemblySearchHook * next;

  hook = assembly_search_hook;
  goto <D.17716>;
  <D.17715>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17716>:
  if (hook != 0B) goto <D.17715>; else goto <D.17717>;
  <D.17717>:
}


free_assembly_preload_hooks ()
{
  struct AssemblyPreLoadHook * hook;
  struct AssemblyPreLoadHook * next;

  hook = assembly_preload_hook;
  goto <D.17771>;
  <D.17770>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17771>:
  if (hook != 0B) goto <D.17770>; else goto <D.17772>;
  <D.17772>:
  hook = assembly_refonly_preload_hook;
  goto <D.17774>;
  <D.17773>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17774>:
  if (hook != 0B) goto <D.17773>; else goto <D.17775>;
  <D.17775>:
}


__attribute__((visibility ("hidden")))
mono_assembly_cleanup_domain_bindings (guint32 domain_id)
{
  int D.20281;
  unsigned int D.20282;
  struct GSList * D.20285;
  struct GSList * D.20287;
  struct GSList * * iter;

  mono_assembly_binding_lock ();
  iter = &loaded_assembly_bindings;
  goto <D.18224>;
  <D.18223>:
  {
    struct GSList * l;
    struct MonoAssemblyBindingInfo * info;

    l = *iter;
    info = l->data;
    D.20281 = info->domain_id;
    D.20282 = (unsigned int) D.20281;
    if (D.20282 == domain_id) goto <D.20283>; else goto <D.20284>;
    <D.20283>:
    D.20285 = l->next;
    *iter = D.20285;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
    monoeg_g_slist_free_1 (l);
    goto <D.20286>;
    <D.20284>:
    iter = &l->next;
    <D.20286>:
  }
  <D.18224>:
  D.20287 = *iter;
  if (D.20287 != 0B) goto <D.18223>; else goto <D.18225>;
  <D.18225>:
  mono_assembly_binding_unlock ();
}


mono_assembly_set_main (struct MonoAssembly * assembly)
{
  main_assembly = assembly;
}


mono_assembly_get_main ()
{
  struct MonoAssembly * D.20288;

  D.20288 = main_assembly;
  return D.20288;
}


mono_assembly_get_image (struct MonoAssembly * assembly)
{
  struct MonoImage * D.20290;

  D.20290 = assembly->image;
  return D.20290;
}


mono_register_bundled_assemblies (const struct MonoBundledAssembly * * assemblies)
{
  bundles = assemblies;
}


__attribute__((visibility ("hidden")))
mono_assembly_has_skip_verification (struct MonoAssembly * assembly)
{
  <unnamed-unsigned:2> D.20292;
  int D.20293;
  int D.20294;
  gboolean D.20297;
  int D.20298;
  struct MonoImage * D.20299;
  unsigned int D.20300;
  unsigned int D.20301;
  unsigned int D.20304;
  unsigned int D.20307;
  const char * blob.82;
  const char * blob.83;
  unsigned int D.20310;
  sizetype D.20313;
  const char * D.20314;
  int D.20315;
  <unnamed-unsigned:24> D.20318;
  int D.20319;
  struct MonoTableInfo * t;
  guint32 cols[3];
  const char * blob;
  int i;
  int len;

  try
    {
      D.20292 = assembly->skipverification;
      D.20293 = (int) D.20292;
      D.20294 = D.20293 & 2;
      if (D.20294 != 0) goto <D.20295>; else goto <D.20296>;
      <D.20295>:
      D.20292 = assembly->skipverification;
      D.20298 = (int) D.20292;
      D.20297 = D.20298 & 1;
      return D.20297;
      <D.20296>:
      D.20299 = assembly->image;
      t = &D.20299->tables[14];
      i = 0;
      goto <D.18281>;
      <D.18280>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.20300 = cols[1];
      D.20301 = D.20300 & 3;
      if (D.20301 != 2) goto <D.20302>; else goto <D.20303>;
      <D.20302>:
      // predicted unlikely by continue predictor.
      goto <D.18279>;
      <D.20303>:
      D.20304 = cols[0];
      if (D.20304 != 8) goto <D.20305>; else goto <D.20306>;
      <D.20305>:
      // predicted unlikely by continue predictor.
      goto <D.18279>;
      <D.20306>:
      D.20299 = assembly->image;
      D.20307 = cols[2];
      blob.82 = mono_metadata_blob_heap (D.20299, D.20307);
      blob = blob.82;
      blob.83 = blob;
      D.20310 = mono_metadata_decode_blob_size (blob.83, &blob);
      len = (int) D.20310;
      if (len == 0) goto <D.20311>; else goto <D.20312>;
      <D.20311>:
      // predicted unlikely by continue predictor.
      goto <D.18279>;
      <D.20312>:
      blob.83 = blob;
      blob.83 = blob;
      D.20313 = (sizetype) len;
      D.20314 = blob.83 + D.20313;
      D.20315 = mono_assembly_try_decode_skip_verification (blob.83, D.20314);
      if (D.20315 != 0) goto <D.20316>; else goto <D.20317>;
      <D.20316>:
      assembly->skipverification = 3;
      D.20297 = 1;
      return D.20297;
      <D.20317>:
      <D.18279>:
      i = i + 1;
      <D.18281>:
      D.20318 = t->rows;
      D.20319 = (int) D.20318;
      if (D.20319 > i) goto <D.18280>; else goto <D.18282>;
      <D.18282>:
      assembly->skipverification = 2;
      D.20297 = 0;
      return D.20297;
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
    }
}


mono_assembly_try_decode_skip_verification (const char * p, const char * endn)
{
  const char * p.84;
  char D.20323;
  long int endn.85;
  long int p.86;
  long int D.20328;
  char * D.20331;
  _Bool D.20332;
  gboolean D.20333;
  const char * p.87;
  const char * p.88;
  char D.20336;
  unsigned int D.20339;
  unsigned int D.20340;
  int iftmp.89;
  unsigned int len.90;
  int D.20346;
  sizetype D.20348;
  const char * p.91;
  unsigned int D.20350;
  sizetype D.20353;
  unsigned int D.20354;
  int D.20355;
  int abort_decoding.92;
  const char * p.93;
  int i;
  int j;
  int num;
  int len;
  int params_len;

  p.84 = p;
  D.20323 = *p.84;
  if (D.20323 == 60) goto <D.20324>; else goto <D.20325>;
  <D.20324>:
  {
    gsize read;
    gsize written;
    char * res;

    try
      {
        p.84 = p;
        endn.85 = (long int) endn;
        p.84 = p;
        p.86 = (long int) p.84;
        D.20328 = endn.85 - p.86;
        res = monoeg_g_convert (p.84, D.20328, "UTF-8", "UTF-16LE", &read, &written, 0B);
        if (res != 0B) goto <D.20329>; else goto <D.20330>;
        <D.20329>:
        {
          gboolean found;

          D.20331 = strstr (res, "\"SkipVerification\"");
          D.20332 = D.20331 != 0B;
          found = (gboolean) D.20332;
          monoeg_g_free (res);
          D.20333 = found;
          return D.20333;
        }
        <D.20330>:
        D.20333 = 0;
        return D.20333;
      }
    finally
      {
        read = {CLOBBER};
        written = {CLOBBER};
      }
  }
  <D.20325>:
  p.84 = p;
  p.87 = p.84;
  p.88 = p.87 + 1;
  p = p.88;
  D.20336 = *p.87;
  if (D.20336 != 46) goto <D.20337>; else goto <D.20338>;
  <D.20337>:
  D.20333 = 0;
  return D.20333;
  <D.20338>:
  p.84 = p;
  D.20339 = mono_metadata_decode_value (p.84, &p);
  num = (int) D.20339;
  i = 0;
  goto <D.18269>;
  <D.18268>:
  {
    gboolean is_valid;
    gboolean abort_decoding;

    try
      {
        is_valid = 0;
        abort_decoding = 0;
        p.84 = p;
        D.20340 = mono_metadata_decode_value (p.84, &p);
        len = (int) D.20340;
        len.90 = (unsigned int) len;
        if (len.90 > 54) goto <D.20345>; else goto <D.20342>;
        <D.20345>:
        p.84 = p;
        D.20346 = memcmp (p.84, "System.Security.Permissions.SecurityPermissionAttribute", 55);
        if (D.20346 == 0) goto <D.20347>; else goto <D.20342>;
        <D.20347>:
        iftmp.89 = 1;
        goto <D.20343>;
        <D.20342>:
        iftmp.89 = 0;
        <D.20343>:
        is_valid = iftmp.89;
        p.84 = p;
        D.20348 = (sizetype) len;
        p.91 = p.84 + D.20348;
        p = p.91;
        p.84 = p;
        D.20350 = mono_metadata_decode_value (p.84, &p);
        params_len = (int) D.20350;
        if (is_valid != 0) goto <D.20351>; else goto <D.20352>;
        <D.20351>:
        {
          const char * params_end;

          p.84 = p;
          D.20353 = (sizetype) params_len;
          params_end = p.84 + D.20353;
          p.84 = p;
          D.20354 = mono_metadata_decode_value (p.84, &p);
          len = (int) D.20354;
          j = 0;
          goto <D.18267>;
          <D.18266>:
          p.84 = p;
          D.20355 = mono_assembly_try_decode_skip_verification_param (p.84, &p, &abort_decoding);
          if (D.20355 != 0) goto <D.20356>; else goto <D.20357>;
          <D.20356>:
          D.20333 = 1;
          return D.20333;
          <D.20357>:
          abort_decoding.92 = abort_decoding;
          if (abort_decoding.92 != 0) goto <D.18265>; else goto <D.20359>;
          <D.20359>:
          j = j + 1;
          <D.18267>:
          if (j < len) goto <D.18266>; else goto <D.18265>;
          <D.18265>:
          p = params_end;
        }
        goto <D.20360>;
        <D.20352>:
        p.84 = p;
        D.20353 = (sizetype) params_len;
        p.93 = p.84 + D.20353;
        p = p.93;
        <D.20360>:
      }
    finally
      {
        abort_decoding = {CLOBBER};
      }
  }
  i = i + 1;
  <D.18269>:
  if (i < num) goto <D.18268>; else goto <D.18270>;
  <D.18270>:
  D.20333 = 0;
  return D.20333;
}


mono_assembly_try_decode_skip_verification_param (const char * p, const char * * resp, gboolean * abort_decoding)
{
  const char * p.94;
  const char * p.95;
  const char * p.96;
  char D.20369;
  int D.20370;
  gboolean D.20371;
  const char * p.97;
  const char * p.98;
  char D.20374;
  unsigned int D.20377;
  unsigned int len.99;
  int D.20381;
  sizetype D.20384;
  const char * p.100;
  char D.20386;
  sizetype D.20387;
  const char * p.101;
  int len;

  p.94 = p;
  p.95 = p.94;
  p.96 = p.95 + 1;
  p = p.96;
  D.20369 = *p.95;
  D.20370 = (int) D.20369;
  switch (D.20370) <default: <D.18248>, case 83: <D.18247>, case 84: <D.18245>>
  <D.18245>:
  goto <D.18246>;
  <D.18247>:
  <D.18248>:
  *abort_decoding = 1;
  D.20371 = 0;
  return D.20371;
  <D.18246>:
  p.94 = p;
  p.97 = p.94;
  p.98 = p.97 + 1;
  p = p.98;
  D.20374 = *p.97;
  if (D.20374 != 2) goto <D.20375>; else goto <D.20376>;
  <D.20375>:
  *abort_decoding = 1;
  D.20371 = 0;
  return D.20371;
  <D.20376>:
  p.94 = p;
  D.20377 = mono_metadata_decode_value (p.94, &p);
  len = (int) D.20377;
  len.99 = (unsigned int) len;
  if (len.99 > 15) goto <D.20379>; else goto <D.20380>;
  <D.20379>:
  p.94 = p;
  D.20381 = memcmp (p.94, "SkipVerification", 16);
  if (D.20381 == 0) goto <D.20382>; else goto <D.20383>;
  <D.20382>:
  p.94 = p;
  D.20384 = (sizetype) len;
  p.100 = p.94 + D.20384;
  p = p.100;
  p.94 = p;
  D.20386 = *p.94;
  D.20371 = (gboolean) D.20386;
  return D.20371;
  <D.20383>:
  <D.20380>:
  p.94 = p;
  D.20384 = (sizetype) len;
  D.20387 = D.20384 + 1;
  p.101 = p.94 + D.20387;
  p = p.101;
  p.94 = p;
  *resp = p.94;
  D.20371 = 0;
  return D.20371;
}