mono_public_tokens_are_equal (const unsigned char * pubt1, const unsigned char * pubt2)
{
  gboolean D.18473;
  int D.18474;
  _Bool D.18475;

  D.18474 = memcmp (pubt1, pubt2, 16);
  D.18475 = D.18474 == 0;
  D.18473 = (gboolean) D.18475;
  return D.18473;
}


mono_set_assemblies_path (const char * path)
{
  char * * assemblies_path.0;
  char * D.18480;
  char D.18481;
  char * * dest.1;
  const gchar * D.18485;
  int D.18490;
  char * * splitted;
  char * * dest;

  splitted = monoeg_g_strsplit (path, ":", 1000);
  assemblies_path.0 = assemblies_path;
  if (assemblies_path.0 != 0B) goto <D.18478>; else goto <D.18479>;
  <D.18478>:
  assemblies_path.0 = assemblies_path;
  monoeg_g_strfreev (assemblies_path.0);
  <D.18479>:
  dest = splitted;
  assemblies_path = dest;
  goto <D.17317>;
  <D.17316>:
  D.18480 = *splitted;
  D.18481 = *D.18480;
  if (D.18481 != 0) goto <D.18482>; else goto <D.18483>;
  <D.18482>:
  dest.1 = dest;
  dest = dest.1 + 8;
  D.18480 = *splitted;
  *dest.1 = D.18480;
  <D.18483>:
  splitted = splitted + 8;
  <D.17317>:
  D.18480 = *splitted;
  if (D.18480 != 0B) goto <D.17316>; else goto <D.17318>;
  <D.17318>:
  D.18480 = *splitted;
  *dest = D.18480;
  D.18485 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.18485 == 0B) goto <D.18486>; else goto <D.18487>;
  <D.18486>:
  return;
  <D.18487>:
  splitted = assemblies_path;
  goto <D.17320>;
  <D.17319>:
  D.18480 = *splitted;
  D.18481 = *D.18480;
  if (D.18481 != 0) goto <D.18488>; else goto <D.18489>;
  <D.18488>:
  D.18480 = *splitted;
  D.18490 = monoeg_g_file_test (D.18480, 4);
  if (D.18490 == 0) goto <D.18491>; else goto <D.18492>;
  <D.18491>:
  D.18480 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_PATH doesn\'t exist or has wrong permissions.", D.18480);
  <D.18492>:
  <D.18489>:
  splitted = splitted + 8;
  <D.17320>:
  D.18480 = *splitted;
  if (D.18480 != 0B) goto <D.17319>; else goto <D.17321>;
  <D.17321>:
}


mono_assembly_names_equal (struct MonoAssemblyName * l, struct MonoAssemblyName * r)
{
  const char * D.18496;
  const char * D.18498;
  mono_bool D.18499;
  int D.17393;
  const char * D.18502;
  const char * D.18505;
  int D.17402;
  long unsigned int D.18510;
  long unsigned int D.18511;
  long unsigned int D.18512;
  long unsigned int D.18513;
  unsigned char D.18522;
  unsigned char D.18524;
  mono_byte[17] * D.18525;
  mono_byte[17] * D.18526;
  int D.18527;

  D.18496 = l->name;
  if (D.18496 == 0B) goto <D.18494>; else goto <D.18497>;
  <D.18497>:
  D.18498 = r->name;
  if (D.18498 == 0B) goto <D.18494>; else goto <D.18495>;
  <D.18494>:
  D.18499 = 0;
  return D.18499;
  <D.18495>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.18498 = r->name;
    D.18496 = l->name;
    D.17393 = __builtin_strcmp (D.18496, D.18498);
  }
  if (D.17393 != 0) goto <D.18500>; else goto <D.18501>;
  <D.18500>:
  D.18499 = 0;
  return D.18499;
  <D.18501>:
  D.18502 = l->culture;
  if (D.18502 != 0B) goto <D.18503>; else goto <D.18504>;
  <D.18503>:
  D.18505 = r->culture;
  if (D.18505 != 0B) goto <D.18506>; else goto <D.18507>;
  <D.18506>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.18505 = r->culture;
    D.18502 = l->culture;
    D.17402 = __builtin_strcmp (D.18502, D.18505);
  }
  if (D.17402 != 0) goto <D.18508>; else goto <D.18509>;
  <D.18508>:
  D.18499 = 0;
  return D.18499;
  <D.18509>:
  <D.18507>:
  <D.18504>:
  D.18510 = BIT_FIELD_REF <*l, 64, 512>;
  D.18511 = D.18510;
  D.18512 = BIT_FIELD_REF <*r, 64, 512>;
  D.18513 = D.18512;
  if (D.18511 != D.18513) goto <D.18514>; else goto <D.18515>;
  <D.18514>:
  D.18510 = BIT_FIELD_REF <*l, 64, 512>;
  D.18511 = D.18510;
  if (D.18511 != 0) goto <D.18516>; else goto <D.18517>;
  <D.18516>:
  D.18512 = BIT_FIELD_REF <*r, 64, 512>;
  D.18513 = D.18512;
  if (D.18513 != 0) goto <D.18518>; else goto <D.18519>;
  <D.18518>:
  D.18499 = 0;
  return D.18499;
  <D.18519>:
  <D.18517>:
  <D.18515>:
  D.18522 = l->public_key_token[0];
  if (D.18522 == 0) goto <D.18520>; else goto <D.18523>;
  <D.18523>:
  D.18524 = r->public_key_token[0];
  if (D.18524 == 0) goto <D.18520>; else goto <D.18521>;
  <D.18520>:
  D.18499 = 1;
  return D.18499;
  <D.18521>:
  D.18525 = &r->public_key_token;
  D.18526 = &l->public_key_token;
  D.18527 = mono_public_tokens_are_equal (D.18526, D.18525);
  if (D.18527 == 0) goto <D.18528>; else goto <D.18529>;
  <D.18528>:
  D.18499 = 0;
  return D.18499;
  <D.18529>:
  D.18499 = 1;
  return D.18499;
}


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

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


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

  if (str != 0B) goto <D.18532>; else goto <D.18533>;
  <D.18532>:
  D.18534 = __strdup (str);
  return D.18534;
  <D.18533>:
  D.18534 = 0B;
  return D.18534;
}


mono_assembly_getrootdir ()
{
  const char * D.18536;

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


mono_set_dirs (const char * assembly_dir, const char * config_dir)
{
  if (assembly_dir == 0B) goto <D.18538>; else goto <D.18539>;
  <D.18538>:
  assembly_dir = "/usr/lib";
  <D.18539>:
  if (config_dir == 0B) goto <D.18540>; else goto <D.18541>;
  <D.18540>:
  config_dir = "/etc";
  <D.18541>:
  mono_assembly_setrootdir (assembly_dir);
  mono_set_config_dir (config_dir);
}


mono_set_rootdir ()
{
  long int D.18542;
  int D.18545;
  long int D.18546;
  char buf[4096];
  int s;
  char * str;

  try
    {
      D.18542 = readlink ("/proc/self/exe", &buf, 4095);
      s = (int) D.18542;
      if (s != -1) goto <D.18543>; else goto <D.18544>;
      <D.18543>:
      buf[s] = 0;
      set_dirs (&buf);
      return;
      <D.18544>:
      D.18545 = getpid ();
      str = monoeg_g_strdup_printf ("/proc/%d/path/a.out", D.18545);
      D.18546 = readlink (str, &buf, 4095);
      s = (int) D.18546;
      monoeg_g_free (str);
      if (s != -1) goto <D.18547>; else goto <D.18548>;
      <D.18547>:
      buf[s] = 0;
      set_dirs (&buf);
      return;
      <D.18548>:
      fallback ();
    }
  finally
    {
      buf = {CLOBBER};
    }
}


readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  long unsigned int D.18552;
  int D.18555;
  ssize_t D.18558;
  long unsigned int D.18559;
  long unsigned int D.18560;
  long unsigned int D.18563;

  D.18552 = __builtin_object_size (__buf, 1);
  if (D.18552 != 18446744073709551615) goto <D.18553>; else goto <D.18554>;
  <D.18553>:
  D.18555 = __builtin_constant_p (__len);
  if (D.18555 == 0) goto <D.18556>; else goto <D.18557>;
  <D.18556>:
  D.18559 = __builtin_object_size (__buf, 1);
  D.18558 = __readlink_chk (__path, __buf, __len, D.18559);
  return D.18558;
  <D.18557>:
  D.18560 = __builtin_object_size (__buf, 1);
  if (D.18560 < __len) goto <D.18561>; else goto <D.18562>;
  <D.18561>:
  D.18563 = __builtin_object_size (__buf, 1);
  D.18558 = __readlink_chk_warn (__path, __buf, __len, D.18563);
  return D.18558;
  <D.18562>:
  <D.18554>:
  D.18558 = __readlink_alias (__path, __buf, __len);
  return D.18558;
}


set_dirs (char * exe)
{
  int D.18567;
  int D.18569;
  char * base;
  char * config;
  char * lib;
  char * mono;
  struct stat buf;

  try
    {
      D.18567 = strncmp (exe, "/usr/bin/", 9);
      if (D.18567 == 0) goto <D.18565>; else goto <D.18568>;
      <D.18568>:
      base = compute_base (exe);
      if (base == 0B) goto <D.18565>; else goto <D.18566>;
      <D.18565>:
      fallback ();
      return;
      <D.18566>:
      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.18569 = stat (mono, &buf);
      if (D.18569 == -1) goto <D.18570>; else goto <D.18571>;
      <D.18570>:
      fallback ();
      goto <D.18572>;
      <D.18571>:
      mono_set_dirs (lib, config);
      <D.18572>:
      monoeg_g_free (config);
      monoeg_g_free (lib);
      monoeg_g_free (mono);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


compute_base (char * path)
{
  char * D.18578;
  int D.17437;
  int iftmp.2;
  int D.17436;
  const char[6] * D.18582;
  unsigned char D.18583;
  int D.18584;
  unsigned char D.18585;
  int D.18586;
  _Bool D.18587;
  _Bool D.18588;
  _Bool D.18589;
  const unsigned char * D.18592;
  unsigned char D.18593;
  int D.18594;
  const unsigned char * D.18595;
  unsigned char D.18596;
  int D.18597;
  _Bool D.18598;
  _Bool D.18599;
  const unsigned char * D.18602;
  unsigned char D.18603;
  int D.18604;
  const unsigned char * D.18605;
  unsigned char D.18606;
  int D.18607;
  _Bool D.18608;
  _Bool D.18609;
  const unsigned char * D.18612;
  unsigned char D.18613;
  int D.18614;
  const unsigned char * D.18615;
  unsigned char D.18616;
  int D.18617;
  int D.17446;
  int iftmp.3;
  int D.17445;
  const char[11] * D.18624;
  unsigned char D.18625;
  int D.18626;
  unsigned char D.18627;
  int D.18628;
  _Bool D.18629;
  _Bool D.18630;
  _Bool D.18631;
  const unsigned char * D.18634;
  unsigned char D.18635;
  int D.18636;
  const unsigned char * D.18637;
  unsigned char D.18638;
  int D.18639;
  _Bool D.18640;
  _Bool D.18641;
  const unsigned char * D.18644;
  unsigned char D.18645;
  int D.18646;
  const unsigned char * D.18647;
  unsigned char D.18648;
  int D.18649;
  _Bool D.18650;
  _Bool D.18651;
  const unsigned char * D.18654;
  unsigned char D.18655;
  int D.18656;
  const unsigned char * D.18657;
  unsigned char D.18658;
  int D.18659;
  int D.17455;
  int iftmp.4;
  int D.17454;
  const char[8] * D.18666;
  unsigned char D.18667;
  int D.18668;
  unsigned char D.18669;
  int D.18670;
  _Bool D.18671;
  _Bool D.18672;
  _Bool D.18673;
  const unsigned char * D.18676;
  unsigned char D.18677;
  int D.18678;
  const unsigned char * D.18679;
  unsigned char D.18680;
  int D.18681;
  _Bool D.18682;
  _Bool D.18683;
  const unsigned char * D.18686;
  unsigned char D.18687;
  int D.18688;
  const unsigned char * D.18689;
  unsigned char D.18690;
  int D.18691;
  _Bool D.18692;
  _Bool D.18693;
  const unsigned char * D.18696;
  unsigned char D.18697;
  int D.18698;
  const unsigned char * D.18699;
  unsigned char D.18700;
  int D.18701;
  int D.17464;
  int iftmp.5;
  int D.17463;
  const char[9] * D.18708;
  unsigned char D.18709;
  int D.18710;
  unsigned char D.18711;
  int D.18712;
  _Bool D.18713;
  _Bool D.18714;
  _Bool D.18715;
  const unsigned char * D.18718;
  unsigned char D.18719;
  int D.18720;
  const unsigned char * D.18721;
  unsigned char D.18722;
  int D.18723;
  _Bool D.18724;
  _Bool D.18725;
  const unsigned char * D.18728;
  unsigned char D.18729;
  int D.18730;
  const unsigned char * D.18731;
  unsigned char D.18732;
  int D.18733;
  _Bool D.18734;
  _Bool D.18735;
  const unsigned char * D.18738;
  unsigned char D.18739;
  int D.18740;
  const unsigned char * D.18741;
  unsigned char D.18742;
  int D.18743;
  int D.17473;
  int iftmp.6;
  int D.17472;
  const char[6] * D.18750;
  unsigned char D.18751;
  int D.18752;
  unsigned char D.18753;
  int D.18754;
  _Bool D.18755;
  _Bool D.18756;
  _Bool D.18757;
  const unsigned char * D.18760;
  unsigned char D.18761;
  int D.18762;
  const unsigned char * D.18763;
  unsigned char D.18764;
  int D.18765;
  _Bool D.18766;
  _Bool D.18767;
  const unsigned char * D.18770;
  unsigned char D.18771;
  int D.18772;
  const unsigned char * D.18773;
  unsigned char D.18774;
  int D.18775;
  _Bool D.18776;
  _Bool D.18777;
  const unsigned char * D.18780;
  unsigned char D.18781;
  int D.18782;
  const unsigned char * D.18783;
  unsigned char D.18784;
  int D.18785;
  int D.17482;
  int iftmp.7;
  int D.17481;
  const char[10] * D.18792;
  unsigned char D.18793;
  int D.18794;
  unsigned char D.18795;
  int D.18796;
  _Bool D.18797;
  _Bool D.18798;
  _Bool D.18799;
  const unsigned char * D.18802;
  unsigned char D.18803;
  int D.18804;
  const unsigned char * D.18805;
  unsigned char D.18806;
  int D.18807;
  _Bool D.18808;
  _Bool D.18809;
  const unsigned char * D.18812;
  unsigned char D.18813;
  int D.18814;
  const unsigned char * D.18815;
  unsigned char D.18816;
  int D.18817;
  _Bool D.18818;
  _Bool D.18819;
  const unsigned char * D.18822;
  unsigned char D.18823;
  int D.18824;
  const unsigned char * D.18825;
  unsigned char D.18826;
  int D.18827;
  int D.17491;
  int iftmp.8;
  int D.17490;
  const char[5] * D.18836;
  unsigned char D.18837;
  int D.18838;
  unsigned char D.18839;
  int D.18840;
  _Bool D.18841;
  _Bool D.18842;
  _Bool D.18843;
  const unsigned char * D.18846;
  unsigned char D.18847;
  int D.18848;
  const unsigned char * D.18849;
  unsigned char D.18850;
  int D.18851;
  _Bool D.18852;
  _Bool D.18853;
  const unsigned char * D.18856;
  unsigned char D.18857;
  int D.18858;
  const unsigned char * D.18859;
  unsigned char D.18860;
  int D.18861;
  _Bool D.18862;
  _Bool D.18863;
  const unsigned char * D.18866;
  unsigned char D.18867;
  int D.18868;
  const unsigned char * D.18869;
  unsigned char D.18870;
  int D.18871;
  char * p;

  p = strrchr (path, 47);
  if (p == 0B) goto <D.18576>; else goto <D.18577>;
  <D.18576>:
  D.18578 = 0B;
  return D.18578;
  <D.18577>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.18580>; else goto <D.18581>;
    <D.18580>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = p;
      D.18582 = "/mono";
      D.18583 = MEM[(const unsigned char *)D.18582];
      D.18584 = (int) D.18583;
      D.18585 = *__s2;
      D.18586 = (int) D.18585;
      __result = D.18584 - D.18586;
      {
        D.18587 = __s2_len != 0;
        D.18588 = __result == 0;
        D.18589 = D.18587 & D.18588;
        if (D.18589 != 0) goto <D.18590>; else goto <D.18591>;
        <D.18590>:
        D.18592 = &MEM[(void *)"/mono" + 1B];
        D.18593 = *D.18592;
        D.18594 = (int) D.18593;
        D.18595 = __s2 + 1;
        D.18596 = *D.18595;
        D.18597 = (int) D.18596;
        __result = D.18594 - D.18597;
        D.18598 = __s2_len > 1;
        D.18588 = __result == 0;
        D.18599 = D.18598 & D.18588;
        if (D.18599 != 0) goto <D.18600>; else goto <D.18601>;
        <D.18600>:
        D.18602 = &MEM[(void *)"/mono" + 2B];
        D.18603 = *D.18602;
        D.18604 = (int) D.18603;
        D.18605 = __s2 + 2;
        D.18606 = *D.18605;
        D.18607 = (int) D.18606;
        __result = D.18604 - D.18607;
        D.18608 = __s2_len > 2;
        D.18588 = __result == 0;
        D.18609 = D.18608 & D.18588;
        if (D.18609 != 0) goto <D.18610>; else goto <D.18611>;
        <D.18610>:
        D.18612 = &MEM[(void *)"/mono" + 3B];
        D.18613 = *D.18612;
        D.18614 = (int) D.18613;
        D.18615 = __s2 + 3;
        D.18616 = *D.18615;
        D.18617 = (int) D.18616;
        __result = D.18614 - D.18617;
        <D.18611>:
        <D.18601>:
        <D.18591>:
      }
      D.17436 = __result;
    }
    iftmp.2 = -D.17436;
    goto <D.18618>;
    <D.18581>:
    iftmp.2 = __builtin_strcmp (p, "/mono");
    <D.18618>:
    D.17437 = iftmp.2;
  }
  if (D.17437 != 0) goto <D.18619>; else goto <D.18620>;
  <D.18619>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.18622>; else goto <D.18623>;
    <D.18622>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = p;
      D.18624 = "/mono-sgen";
      D.18625 = MEM[(const unsigned char *)D.18624];
      D.18626 = (int) D.18625;
      D.18627 = *__s2;
      D.18628 = (int) D.18627;
      __result = D.18626 - D.18628;
      {
        D.18629 = __s2_len != 0;
        D.18630 = __result == 0;
        D.18631 = D.18629 & D.18630;
        if (D.18631 != 0) goto <D.18632>; else goto <D.18633>;
        <D.18632>:
        D.18634 = &MEM[(void *)"/mono-sgen" + 1B];
        D.18635 = *D.18634;
        D.18636 = (int) D.18635;
        D.18637 = __s2 + 1;
        D.18638 = *D.18637;
        D.18639 = (int) D.18638;
        __result = D.18636 - D.18639;
        D.18640 = __s2_len > 1;
        D.18630 = __result == 0;
        D.18641 = D.18640 & D.18630;
        if (D.18641 != 0) goto <D.18642>; else goto <D.18643>;
        <D.18642>:
        D.18644 = &MEM[(void *)"/mono-sgen" + 2B];
        D.18645 = *D.18644;
        D.18646 = (int) D.18645;
        D.18647 = __s2 + 2;
        D.18648 = *D.18647;
        D.18649 = (int) D.18648;
        __result = D.18646 - D.18649;
        D.18650 = __s2_len > 2;
        D.18630 = __result == 0;
        D.18651 = D.18650 & D.18630;
        if (D.18651 != 0) goto <D.18652>; else goto <D.18653>;
        <D.18652>:
        D.18654 = &MEM[(void *)"/mono-sgen" + 3B];
        D.18655 = *D.18654;
        D.18656 = (int) D.18655;
        D.18657 = __s2 + 3;
        D.18658 = *D.18657;
        D.18659 = (int) D.18658;
        __result = D.18656 - D.18659;
        <D.18653>:
        <D.18643>:
        <D.18633>:
      }
      D.17445 = __result;
    }
    iftmp.3 = -D.17445;
    goto <D.18660>;
    <D.18623>:
    iftmp.3 = __builtin_strcmp (p, "/mono-sgen");
    <D.18660>:
    D.17446 = iftmp.3;
  }
  if (D.17446 != 0) goto <D.18661>; else goto <D.18662>;
  <D.18661>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.18664>; else goto <D.18665>;
    <D.18664>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = p;
      D.18666 = "/pedump";
      D.18667 = MEM[(const unsigned char *)D.18666];
      D.18668 = (int) D.18667;
      D.18669 = *__s2;
      D.18670 = (int) D.18669;
      __result = D.18668 - D.18670;
      {
        D.18671 = __s2_len != 0;
        D.18672 = __result == 0;
        D.18673 = D.18671 & D.18672;
        if (D.18673 != 0) goto <D.18674>; else goto <D.18675>;
        <D.18674>:
        D.18676 = &MEM[(void *)"/pedump" + 1B];
        D.18677 = *D.18676;
        D.18678 = (int) D.18677;
        D.18679 = __s2 + 1;
        D.18680 = *D.18679;
        D.18681 = (int) D.18680;
        __result = D.18678 - D.18681;
        D.18682 = __s2_len > 1;
        D.18672 = __result == 0;
        D.18683 = D.18682 & D.18672;
        if (D.18683 != 0) goto <D.18684>; else goto <D.18685>;
        <D.18684>:
        D.18686 = &MEM[(void *)"/pedump" + 2B];
        D.18687 = *D.18686;
        D.18688 = (int) D.18687;
        D.18689 = __s2 + 2;
        D.18690 = *D.18689;
        D.18691 = (int) D.18690;
        __result = D.18688 - D.18691;
        D.18692 = __s2_len > 2;
        D.18672 = __result == 0;
        D.18693 = D.18692 & D.18672;
        if (D.18693 != 0) goto <D.18694>; else goto <D.18695>;
        <D.18694>:
        D.18696 = &MEM[(void *)"/pedump" + 3B];
        D.18697 = *D.18696;
        D.18698 = (int) D.18697;
        D.18699 = __s2 + 3;
        D.18700 = *D.18699;
        D.18701 = (int) D.18700;
        __result = D.18698 - D.18701;
        <D.18695>:
        <D.18685>:
        <D.18675>:
      }
      D.17454 = __result;
    }
    iftmp.4 = -D.17454;
    goto <D.18702>;
    <D.18665>:
    iftmp.4 = __builtin_strcmp (p, "/pedump");
    <D.18702>:
    D.17455 = iftmp.4;
  }
  if (D.17455 != 0) goto <D.18703>; else goto <D.18704>;
  <D.18703>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 8;
    if (__s2_len <= 3) goto <D.18706>; else goto <D.18707>;
    <D.18706>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = p;
      D.18708 = "/monodis";
      D.18709 = MEM[(const unsigned char *)D.18708];
      D.18710 = (int) D.18709;
      D.18711 = *__s2;
      D.18712 = (int) D.18711;
      __result = D.18710 - D.18712;
      {
        D.18713 = __s2_len != 0;
        D.18714 = __result == 0;
        D.18715 = D.18713 & D.18714;
        if (D.18715 != 0) goto <D.18716>; else goto <D.18717>;
        <D.18716>:
        D.18718 = &MEM[(void *)"/monodis" + 1B];
        D.18719 = *D.18718;
        D.18720 = (int) D.18719;
        D.18721 = __s2 + 1;
        D.18722 = *D.18721;
        D.18723 = (int) D.18722;
        __result = D.18720 - D.18723;
        D.18724 = __s2_len > 1;
        D.18714 = __result == 0;
        D.18725 = D.18724 & D.18714;
        if (D.18725 != 0) goto <D.18726>; else goto <D.18727>;
        <D.18726>:
        D.18728 = &MEM[(void *)"/monodis" + 2B];
        D.18729 = *D.18728;
        D.18730 = (int) D.18729;
        D.18731 = __s2 + 2;
        D.18732 = *D.18731;
        D.18733 = (int) D.18732;
        __result = D.18730 - D.18733;
        D.18734 = __s2_len > 2;
        D.18714 = __result == 0;
        D.18735 = D.18734 & D.18714;
        if (D.18735 != 0) goto <D.18736>; else goto <D.18737>;
        <D.18736>:
        D.18738 = &MEM[(void *)"/monodis" + 3B];
        D.18739 = *D.18738;
        D.18740 = (int) D.18739;
        D.18741 = __s2 + 3;
        D.18742 = *D.18741;
        D.18743 = (int) D.18742;
        __result = D.18740 - D.18743;
        <D.18737>:
        <D.18727>:
        <D.18717>:
      }
      D.17463 = __result;
    }
    iftmp.5 = -D.17463;
    goto <D.18744>;
    <D.18707>:
    iftmp.5 = __builtin_strcmp (p, "/monodis");
    <D.18744>:
    D.17464 = iftmp.5;
  }
  if (D.17464 != 0) goto <D.18745>; else goto <D.18746>;
  <D.18745>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.18748>; else goto <D.18749>;
    <D.18748>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = p;
      D.18750 = "/mint";
      D.18751 = MEM[(const unsigned char *)D.18750];
      D.18752 = (int) D.18751;
      D.18753 = *__s2;
      D.18754 = (int) D.18753;
      __result = D.18752 - D.18754;
      {
        D.18755 = __s2_len != 0;
        D.18756 = __result == 0;
        D.18757 = D.18755 & D.18756;
        if (D.18757 != 0) goto <D.18758>; else goto <D.18759>;
        <D.18758>:
        D.18760 = &MEM[(void *)"/mint" + 1B];
        D.18761 = *D.18760;
        D.18762 = (int) D.18761;
        D.18763 = __s2 + 1;
        D.18764 = *D.18763;
        D.18765 = (int) D.18764;
        __result = D.18762 - D.18765;
        D.18766 = __s2_len > 1;
        D.18756 = __result == 0;
        D.18767 = D.18766 & D.18756;
        if (D.18767 != 0) goto <D.18768>; else goto <D.18769>;
        <D.18768>:
        D.18770 = &MEM[(void *)"/mint" + 2B];
        D.18771 = *D.18770;
        D.18772 = (int) D.18771;
        D.18773 = __s2 + 2;
        D.18774 = *D.18773;
        D.18775 = (int) D.18774;
        __result = D.18772 - D.18775;
        D.18776 = __s2_len > 2;
        D.18756 = __result == 0;
        D.18777 = D.18776 & D.18756;
        if (D.18777 != 0) goto <D.18778>; else goto <D.18779>;
        <D.18778>:
        D.18780 = &MEM[(void *)"/mint" + 3B];
        D.18781 = *D.18780;
        D.18782 = (int) D.18781;
        D.18783 = __s2 + 3;
        D.18784 = *D.18783;
        D.18785 = (int) D.18784;
        __result = D.18782 - D.18785;
        <D.18779>:
        <D.18769>:
        <D.18759>:
      }
      D.17472 = __result;
    }
    iftmp.6 = -D.17472;
    goto <D.18786>;
    <D.18749>:
    iftmp.6 = __builtin_strcmp (p, "/mint");
    <D.18786>:
    D.17473 = iftmp.6;
  }
  if (D.17473 != 0) goto <D.18787>; else goto <D.18788>;
  <D.18787>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.18790>; else goto <D.18791>;
    <D.18790>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = p;
      D.18792 = "/monodiet";
      D.18793 = MEM[(const unsigned char *)D.18792];
      D.18794 = (int) D.18793;
      D.18795 = *__s2;
      D.18796 = (int) D.18795;
      __result = D.18794 - D.18796;
      {
        D.18797 = __s2_len != 0;
        D.18798 = __result == 0;
        D.18799 = D.18797 & D.18798;
        if (D.18799 != 0) goto <D.18800>; else goto <D.18801>;
        <D.18800>:
        D.18802 = &MEM[(void *)"/monodiet" + 1B];
        D.18803 = *D.18802;
        D.18804 = (int) D.18803;
        D.18805 = __s2 + 1;
        D.18806 = *D.18805;
        D.18807 = (int) D.18806;
        __result = D.18804 - D.18807;
        D.18808 = __s2_len > 1;
        D.18798 = __result == 0;
        D.18809 = D.18808 & D.18798;
        if (D.18809 != 0) goto <D.18810>; else goto <D.18811>;
        <D.18810>:
        D.18812 = &MEM[(void *)"/monodiet" + 2B];
        D.18813 = *D.18812;
        D.18814 = (int) D.18813;
        D.18815 = __s2 + 2;
        D.18816 = *D.18815;
        D.18817 = (int) D.18816;
        __result = D.18814 - D.18817;
        D.18818 = __s2_len > 2;
        D.18798 = __result == 0;
        D.18819 = D.18818 & D.18798;
        if (D.18819 != 0) goto <D.18820>; else goto <D.18821>;
        <D.18820>:
        D.18822 = &MEM[(void *)"/monodiet" + 3B];
        D.18823 = *D.18822;
        D.18824 = (int) D.18823;
        D.18825 = __s2 + 3;
        D.18826 = *D.18825;
        D.18827 = (int) D.18826;
        __result = D.18824 - D.18827;
        <D.18821>:
        <D.18811>:
        <D.18801>:
      }
      D.17481 = __result;
    }
    iftmp.7 = -D.17481;
    goto <D.18828>;
    <D.18791>:
    iftmp.7 = __builtin_strcmp (p, "/monodiet");
    <D.18828>:
    D.17482 = iftmp.7;
  }
  if (D.17482 != 0) goto <D.18829>; else goto <D.18830>;
  <D.18829>:
  D.18578 = 0B;
  return D.18578;
  <D.18830>:
  <D.18788>:
  <D.18746>:
  <D.18704>:
  <D.18662>:
  <D.18620>:
  *p = 0;
  p = strrchr (path, 47);
  if (p == 0B) goto <D.18831>; else goto <D.18832>;
  <D.18831>:
  D.18578 = 0B;
  return D.18578;
  <D.18832>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.18834>; else goto <D.18835>;
    <D.18834>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = p;
      D.18836 = "/bin";
      D.18837 = MEM[(const unsigned char *)D.18836];
      D.18838 = (int) D.18837;
      D.18839 = *__s2;
      D.18840 = (int) D.18839;
      __result = D.18838 - D.18840;
      {
        D.18841 = __s2_len != 0;
        D.18842 = __result == 0;
        D.18843 = D.18841 & D.18842;
        if (D.18843 != 0) goto <D.18844>; else goto <D.18845>;
        <D.18844>:
        D.18846 = &MEM[(void *)"/bin" + 1B];
        D.18847 = *D.18846;
        D.18848 = (int) D.18847;
        D.18849 = __s2 + 1;
        D.18850 = *D.18849;
        D.18851 = (int) D.18850;
        __result = D.18848 - D.18851;
        D.18852 = __s2_len > 1;
        D.18842 = __result == 0;
        D.18853 = D.18852 & D.18842;
        if (D.18853 != 0) goto <D.18854>; else goto <D.18855>;
        <D.18854>:
        D.18856 = &MEM[(void *)"/bin" + 2B];
        D.18857 = *D.18856;
        D.18858 = (int) D.18857;
        D.18859 = __s2 + 2;
        D.18860 = *D.18859;
        D.18861 = (int) D.18860;
        __result = D.18858 - D.18861;
        D.18862 = __s2_len > 2;
        D.18842 = __result == 0;
        D.18863 = D.18862 & D.18842;
        if (D.18863 != 0) goto <D.18864>; else goto <D.18865>;
        <D.18864>:
        D.18866 = &MEM[(void *)"/bin" + 3B];
        D.18867 = *D.18866;
        D.18868 = (int) D.18867;
        D.18869 = __s2 + 3;
        D.18870 = *D.18869;
        D.18871 = (int) D.18870;
        __result = D.18868 - D.18871;
        <D.18865>:
        <D.18855>:
        <D.18845>:
      }
      D.17490 = __result;
    }
    iftmp.8 = -D.17490;
    goto <D.18872>;
    <D.18835>:
    iftmp.8 = __builtin_strcmp (p, "/bin");
    <D.18872>:
    D.17491 = iftmp.8;
  }
  if (D.17491 != 0) goto <D.18873>; else goto <D.18874>;
  <D.18873>:
  D.18578 = 0B;
  return D.18578;
  <D.18874>:
  *p = 0;
  D.18578 = path;
  return D.18578;
}


stat (const char * __path, struct stat * __statbuf)
{
  int D.18876;

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


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


mono_assemblies_init ()
{
  const char * D.18878;

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


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

  path = monoeg_g_getenv ("MONO_PATH");
  if (path == 0B) goto <D.18881>; else goto <D.18883>;
  <D.18883>:
  assemblies_path.9 = assemblies_path;
  if (assemblies_path.9 != 0B) goto <D.18881>; else goto <D.18882>;
  <D.18881>:
  return;
  <D.18882>:
  mono_set_assemblies_path (path);
}


check_extra_gac_path_env ()
{
  char * * extra_gac_paths.10;
  char * D.18891;
  char D.18892;
  char * * dest.11;
  const gchar * D.18896;
  int D.18901;
  const char * path;
  char * * splitted;
  char * * dest;

  path = monoeg_g_getenv ("MONO_GAC_PREFIX");
  if (path == 0B) goto <D.18886>; else goto <D.18887>;
  <D.18886>:
  return;
  <D.18887>:
  splitted = monoeg_g_strsplit (path, ":", 1000);
  extra_gac_paths.10 = extra_gac_paths;
  if (extra_gac_paths.10 != 0B) goto <D.18889>; else goto <D.18890>;
  <D.18889>:
  extra_gac_paths.10 = extra_gac_paths;
  monoeg_g_strfreev (extra_gac_paths.10);
  <D.18890>:
  dest = splitted;
  extra_gac_paths = dest;
  goto <D.17333>;
  <D.17332>:
  D.18891 = *splitted;
  D.18892 = *D.18891;
  if (D.18892 != 0) goto <D.18893>; else goto <D.18894>;
  <D.18893>:
  dest.11 = dest;
  dest = dest.11 + 8;
  D.18891 = *splitted;
  *dest.11 = D.18891;
  <D.18894>:
  splitted = splitted + 8;
  <D.17333>:
  D.18891 = *splitted;
  if (D.18891 != 0B) goto <D.17332>; else goto <D.17334>;
  <D.17334>:
  D.18891 = *splitted;
  *dest = D.18891;
  D.18896 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.18896 == 0B) goto <D.18897>; else goto <D.18898>;
  <D.18897>:
  return;
  <D.18898>:
  goto <D.17336>;
  <D.17335>:
  D.18891 = *splitted;
  D.18892 = *D.18891;
  if (D.18892 != 0) goto <D.18899>; else goto <D.18900>;
  <D.18899>:
  D.18891 = *splitted;
  D.18901 = monoeg_g_file_test (D.18891, 4);
  if (D.18901 == 0) goto <D.18902>; else goto <D.18903>;
  <D.18902>:
  D.18891 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_GAC_PREFIX doesn\'t exist or has wrong permissions.", D.18891);
  <D.18903>:
  <D.18900>:
  splitted = splitted + 8;
  <D.17336>:
  D.18891 = *splitted;
  if (D.18891 != 0B) goto <D.17335>; else goto <D.17337>;
  <D.17337>:
}


mono_assembly_fill_assembly_name (struct MonoImage * image, struct MonoAssemblyName * aname)
{
  unsigned int D.18905;
  unsigned int D.18906;
  mono_bool D.18909;
  unsigned int D.18910;
  const char * D.18911;
  unsigned int D.18912;
  const char * D.18913;
  unsigned int D.18914;
  unsigned int D.18915;
  short unsigned int D.18916;
  unsigned int D.18917;
  short unsigned int D.18918;
  unsigned int D.18919;
  short unsigned int D.18920;
  unsigned int D.18921;
  short unsigned int D.18922;
  unsigned int D.18923;
  unsigned int D.18924;
  const char * pkey.12;
  const gchar * pkey.13;
  unsigned int D.18929;
  unsigned int len.14;
  const mono_byte * D.18931;
  mono_byte[17] * D.18932;
  const char * D.18936;
  void * D.18938;
  short unsigned int D.18939;
  unsigned int D.18940;
  int D.18941;
  int D.18945;
  struct MonoTableInfo * t;
  guint32 cols[9];
  gint32 machine;
  gint32 flags;

  try
    {
      t = &image->tables[32];
      D.18905 = BIT_FIELD_REF <*t, 32, 64>;
      D.18906 = D.18905 & 16777215;
      if (D.18906 == 0) goto <D.18907>; else goto <D.18908>;
      <D.18907>:
      D.18909 = 0;
      return D.18909;
      <D.18908>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      aname->hash_len = 0;
      aname->hash_value = 0B;
      D.18910 = cols[7];
      D.18911 = mono_metadata_string_heap (image, D.18910);
      aname->name = D.18911;
      D.18912 = cols[8];
      D.18913 = mono_metadata_string_heap (image, D.18912);
      aname->culture = D.18913;
      D.18914 = cols[5];
      aname->flags = D.18914;
      D.18915 = cols[1];
      D.18916 = (short unsigned int) D.18915;
      aname->major = D.18916;
      D.18917 = cols[2];
      D.18918 = (short unsigned int) D.18917;
      aname->minor = D.18918;
      D.18919 = cols[3];
      D.18920 = (short unsigned int) D.18919;
      aname->build = D.18920;
      D.18921 = cols[4];
      D.18922 = (short unsigned int) D.18921;
      aname->revision = D.18922;
      D.18923 = cols[0];
      aname->hash_alg = D.18923;
      D.18924 = cols[6];
      if (D.18924 != 0) goto <D.18925>; else goto <D.18926>;
      <D.18925>:
      {
        guchar * token;
        gchar * encoded;
        const gchar * pkey;
        int len;

        try
          {
            token = monoeg_malloc (8);
            D.18924 = cols[6];
            pkey.12 = mono_metadata_blob_heap (image, D.18924);
            pkey = pkey.12;
            pkey.13 = pkey;
            D.18929 = mono_metadata_decode_blob_size (pkey.13, &pkey);
            len = (int) D.18929;
            pkey.13 = pkey;
            aname->public_key = pkey.13;
            len.14 = (unsigned int) len;
            D.18931 = aname->public_key;
            mono_digest_get_public_token (token, D.18931, len.14);
            encoded = encode_public_tok (token, 8);
            D.18932 = &aname->public_key_token;
            monoeg_g_strlcpy (D.18932, encoded, 17);
            monoeg_g_free (encoded);
            monoeg_g_free (token);
          }
        finally
          {
            pkey = {CLOBBER};
          }
      }
      goto <D.18933>;
      <D.18926>:
      aname->public_key = 0B;
      D.18932 = &aname->public_key_token;
      memset (D.18932, 0, 17);
      <D.18933>:
      D.18924 = cols[6];
      if (D.18924 != 0) goto <D.18934>; else goto <D.18935>;
      <D.18934>:
      D.18924 = cols[6];
      D.18936 = mono_metadata_blob_heap (image, D.18924);
      aname->public_key = D.18936;
      goto <D.18937>;
      <D.18935>:
      aname->public_key = 0B;
      <D.18937>:
      D.18938 = image->image_info;
      D.18939 = MEM[(struct MonoCLIImageInfo *)D.18938].cli_header.coff.coff_machine;
      machine = (gint32) D.18939;
      D.18938 = image->image_info;
      D.18940 = MEM[(struct MonoCLIImageInfo *)D.18938].cli_cli_header.ch_flags;
      flags = (gint32) D.18940;
      switch (machine) <default: <D.17544>, case 332: <D.17539>, case 452: <D.17543>, case 512: <D.17541>, case 34404: <D.17542>>
      <D.17539>:
      D.18941 = flags & 18;
      if (D.18941 != 0) goto <D.18942>; else goto <D.18943>;
      <D.18942>:
      aname->arch = 2;
      goto <D.18944>;
      <D.18943>:
      D.18945 = flags & 112;
      if (D.18945 == 112) goto <D.18946>; else goto <D.18947>;
      <D.18946>:
      aname->arch = 0;
      goto <D.18948>;
      <D.18947>:
      aname->arch = 1;
      <D.18948>:
      <D.18944>:
      goto <D.17540>;
      <D.17541>:
      aname->arch = 3;
      goto <D.17540>;
      <D.17542>:
      aname->arch = 4;
      goto <D.17540>;
      <D.17543>:
      aname->arch = 5;
      goto <D.17540>;
      <D.17544>:
      goto <D.17540>;
      <D.17540>:
      D.18909 = 1;
      return D.18909;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


encode_public_tok (const guchar * token, gint32 len)
{
  int D.18952;
  int D.18953;
  long unsigned int D.18954;
  int D.18955;
  sizetype D.18956;
  gchar * D.18957;
  sizetype D.18958;
  const guchar * D.18959;
  unsigned char D.18960;
  unsigned char D.18961;
  int D.18962;
  char D.18963;
  sizetype D.18964;
  gchar * D.18965;
  int D.18966;
  int D.18967;
  char D.18968;
  sizetype D.18969;
  gchar * D.18970;
  gchar * D.18971;
  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.18952 = len * 2;
  D.18953 = D.18952 + 1;
  D.18954 = (long unsigned int) D.18953;
  res = monoeg_malloc (D.18954);
  i = 0;
  goto <D.17305>;
  <D.17304>:
  D.18955 = i * 2;
  D.18956 = (sizetype) D.18955;
  D.18957 = res + D.18956;
  D.18958 = (sizetype) i;
  D.18959 = token + D.18958;
  D.18960 = *D.18959;
  D.18961 = D.18960 >> 4;
  D.18962 = (int) D.18961;
  D.18963 = allowed[D.18962];
  *D.18957 = D.18963;
  D.18955 = i * 2;
  D.18956 = (sizetype) D.18955;
  D.18964 = D.18956 + 1;
  D.18965 = res + D.18964;
  D.18958 = (sizetype) i;
  D.18959 = token + D.18958;
  D.18960 = *D.18959;
  D.18966 = (int) D.18960;
  D.18967 = D.18966 & 15;
  D.18968 = allowed[D.18967];
  *D.18965 = D.18968;
  i = i + 1;
  <D.17305>:
  if (i < len) goto <D.17304>; else goto <D.17306>;
  <D.17306>:
  D.18952 = len * 2;
  D.18969 = (sizetype) D.18952;
  D.18970 = res + D.18969;
  *D.18970 = 0;
  D.18971 = res;
  return D.18971;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.18975;
  int D.18980;
  void * D.18982;
  long unsigned int D.18983;

  D.18975 = __builtin_constant_p (__len);
  if (D.18975 != 0) goto <D.18976>; else goto <D.18977>;
  <D.18976>:
  if (__len == 0) goto <D.18978>; else goto <D.18979>;
  <D.18978>:
  D.18980 = __builtin_constant_p (__ch);
  if (D.18980 == 0) goto <D.18973>; else goto <D.18981>;
  <D.18981>:
  if (__ch != 0) goto <D.18973>; else goto <D.18974>;
  <D.18973>:
  __warn_memset_zero_len ();
  D.18982 = __dest;
  return D.18982;
  <D.18974>:
  <D.18979>:
  <D.18977>:
  D.18983 = __builtin_object_size (__dest, 0);
  D.18982 = __builtin___memset_chk (__dest, __ch, __len, D.18983);
  return D.18982;
}


mono_stringify_assembly_name (struct MonoAssemblyName * aname)
{
  const char * iftmp.15;
  const char * D.18988;
  const short unsigned int * * D.18990;
  const short unsigned int * D.18991;
  char D.18992;
  long unsigned int D.18993;
  long unsigned int D.18994;
  const short unsigned int * D.18995;
  short unsigned int D.18996;
  int D.18997;
  int D.18998;
  char * D.19000;
  const char * iftmp.16;
  unsigned int D.19002;
  unsigned int D.19003;
  const char * iftmp.17;
  unsigned char D.19008;
  const char * iftmp.18;
  const char * D.19015;
  char D.19017;
  short unsigned int D.19019;
  int D.19020;
  short unsigned int D.19021;
  int D.19022;
  short unsigned int D.19023;
  int D.19024;
  short unsigned int D.19025;
  int D.19026;
  const char * quote;

  D.18988 = aname->name;
  if (D.18988 != 0B) goto <D.18989>; else goto <D.18986>;
  <D.18989>:
  D.18990 = __ctype_b_loc ();
  D.18991 = *D.18990;
  D.18988 = aname->name;
  D.18992 = *D.18988;
  D.18993 = (long unsigned int) D.18992;
  D.18994 = D.18993 * 2;
  D.18995 = D.18991 + D.18994;
  D.18996 = *D.18995;
  D.18997 = (int) D.18996;
  D.18998 = D.18997 & 8192;
  if (D.18998 != 0) goto <D.18999>; else goto <D.18986>;
  <D.18999>:
  iftmp.15 = "\"";
  goto <D.18987>;
  <D.18986>:
  iftmp.15 = "";
  <D.18987>:
  quote = iftmp.15;
  D.19002 = aname->flags;
  D.19003 = D.19002 & 256;
  if (D.19003 != 0) goto <D.19004>; else goto <D.19005>;
  <D.19004>:
  iftmp.16 = ", Retargetable=Yes";
  goto <D.19006>;
  <D.19005>:
  iftmp.16 = "";
  <D.19006>:
  D.19008 = aname->public_key_token[0];
  if (D.19008 != 0) goto <D.19009>; else goto <D.19010>;
  <D.19009>:
  iftmp.17 = &aname->public_key_token;
  goto <D.19011>;
  <D.19010>:
  iftmp.17 = "null";
  <D.19011>:
  D.19015 = aname->culture;
  if (D.19015 != 0B) goto <D.19016>; else goto <D.19013>;
  <D.19016>:
  D.19015 = aname->culture;
  D.19017 = *D.19015;
  if (D.19017 != 0) goto <D.19018>; else goto <D.19013>;
  <D.19018>:
  iftmp.18 = aname->culture;
  goto <D.19014>;
  <D.19013>:
  iftmp.18 = "neutral";
  <D.19014>:
  D.19019 = aname->revision;
  D.19020 = (int) D.19019;
  D.19021 = aname->build;
  D.19022 = (int) D.19021;
  D.19023 = aname->minor;
  D.19024 = (int) D.19023;
  D.19025 = aname->major;
  D.19026 = (int) D.19025;
  D.18988 = aname->name;
  D.19000 = monoeg_g_strdup_printf ("%s%s%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", quote, D.18988, quote, D.19026, D.19024, D.19022, D.19020, iftmp.18, iftmp.17, iftmp.16);
  return D.19000;
}


mono_assembly_addref (struct MonoAssembly * assembly)
{
  int * D.19028;

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.19029;
  unsigned int D.19030;

  D.19030 = __sync_add_and_fetch_4 (val, 1);
  D.19029 = (gint32) D.19030;
  return D.19029;
}


mono_assembly_get_assemblyref (struct MonoImage * image, int index, struct MonoAssemblyName * aname)
{
  unsigned int D.19032;
  const char * hash.19;
  const char * hash.20;
  unsigned int D.19035;
  unsigned int D.19036;
  const char * D.19037;
  unsigned int D.19038;
  const char * D.19039;
  unsigned int D.19040;
  unsigned int D.19041;
  short unsigned int D.19042;
  unsigned int D.19043;
  short unsigned int D.19044;
  unsigned int D.19045;
  short unsigned int D.19046;
  unsigned int D.19047;
  short unsigned int D.19048;
  unsigned int D.19049;
  unsigned int D.19052;
  mono_byte[17] * D.19053;
  struct MonoTableInfo * t;
  guint32 cols[9];
  const char * hash;

  try
    {
      t = &image->tables[35];
      mono_metadata_decode_row (t, index, &cols, 9);
      D.19032 = cols[8];
      hash.19 = mono_metadata_blob_heap (image, D.19032);
      hash = hash.19;
      hash.20 = hash;
      D.19035 = mono_metadata_decode_blob_size (hash.20, &hash);
      aname->hash_len = D.19035;
      hash.20 = hash;
      aname->hash_value = hash.20;
      D.19036 = cols[6];
      D.19037 = mono_metadata_string_heap (image, D.19036);
      aname->name = D.19037;
      D.19038 = cols[7];
      D.19039 = mono_metadata_string_heap (image, D.19038);
      aname->culture = D.19039;
      D.19040 = cols[4];
      aname->flags = D.19040;
      D.19041 = cols[0];
      D.19042 = (short unsigned int) D.19041;
      aname->major = D.19042;
      D.19043 = cols[1];
      D.19044 = (short unsigned int) D.19043;
      aname->minor = D.19044;
      D.19045 = cols[2];
      D.19046 = (short unsigned int) D.19045;
      aname->build = D.19046;
      D.19047 = cols[3];
      D.19048 = (short unsigned int) D.19047;
      aname->revision = D.19048;
      D.19049 = cols[5];
      if (D.19049 != 0) goto <D.19050>; else goto <D.19051>;
      <D.19050>:
      {
        gchar * token;

        D.19052 = aname->flags;
        D.19049 = cols[5];
        token = assemblyref_public_tok (image, D.19049, D.19052);
        D.19053 = &aname->public_key_token;
        monoeg_g_strlcpy (D.19053, token, 17);
        monoeg_g_free (token);
      }
      goto <D.19054>;
      <D.19051>:
      D.19053 = &aname->public_key_token;
      memset (D.19053, 0, 17);
      <D.19054>:
    }
  finally
    {
      cols = {CLOBBER};
      hash = {CLOBBER};
    }
}


assemblyref_public_tok (struct MonoImage * image, guint32 key_index, guint32 flags)
{
  const char * public_tok.21;
  const gchar * public_tok.22;
  unsigned int D.19057;
  unsigned int D.19058;
  unsigned int len.23;
  gchar * D.19062;
  const gchar * public_tok;
  int len;

  try
    {
      public_tok.21 = mono_metadata_blob_heap (image, key_index);
      public_tok = public_tok.21;
      public_tok.22 = public_tok;
      D.19057 = mono_metadata_decode_blob_size (public_tok.22, &public_tok);
      len = (int) D.19057;
      D.19058 = flags & 1;
      if (D.19058 != 0) goto <D.19059>; else goto <D.19060>;
      <D.19059>:
      {
        guchar token[8];

        try
          {
            len.23 = (unsigned int) len;
            public_tok.22 = public_tok;
            mono_digest_get_public_token (&token, public_tok.22, len.23);
            D.19062 = encode_public_tok (&token, 8);
            return D.19062;
          }
        finally
          {
            token = {CLOBBER};
          }
      }
      <D.19060>:
      public_tok.22 = public_tok;
      D.19062 = encode_public_tok (public_tok.22, len);
      return D.19062;
    }
  finally
    {
      public_tok = {CLOBBER};
    }
}


mono_assembly_load_reference (struct MonoImage * image, int index)
{
  _Bool D.19068;
  long int D.19069;
  long int D.19070;
  struct MonoAssembly * * D.19073;
  <unnamed-unsigned:24> D.19076;
  int D.19077;
  int D.19078;
  long unsigned int D.19079;
  long unsigned int D.19080;
  void * D.19081;
  long unsigned int D.19082;
  long unsigned int D.19083;
  struct MonoAssembly * * D.19084;
  _Bool D.19087;
  long int D.19088;
  long int D.19089;
  struct MonoAssembly * D.19096;
  int D.19098;
  int D.17644;
  int iftmp.24;
  int D.17643;
  const char[9] * D.19103;
  unsigned char D.19104;
  int D.19105;
  unsigned char D.19106;
  int D.19107;
  _Bool D.19108;
  _Bool D.19109;
  _Bool D.19110;
  const unsigned char * D.19113;
  unsigned char D.19114;
  int D.19115;
  const unsigned char * D.19116;
  unsigned char D.19117;
  int D.19118;
  _Bool D.19119;
  _Bool D.19120;
  const unsigned char * D.19123;
  unsigned char D.19124;
  int D.19125;
  const unsigned char * D.19126;
  unsigned char D.19127;
  int D.19128;
  _Bool D.19129;
  _Bool D.19130;
  const unsigned char * D.19133;
  unsigned char D.19134;
  int D.19135;
  const unsigned char * D.19136;
  unsigned char D.19137;
  int D.19138;
  const char * D.19140;
  char * D.19143;
  const char * iftmp.25;
  <unnamed type> status.26;
  int * D.19159;
  int D.19160;
  const char * iftmp.27;
  char * D.19168;
  const char * iftmp.28;
  mono_byte[17] * D.19177;
  char D.19178;
  short unsigned int D.19182;
  int D.19183;
  short unsigned int D.19184;
  int D.19185;
  short unsigned int D.19186;
  int D.19187;
  short unsigned int D.19188;
  int D.19189;
  char * D.19190;
  _Bool D.19193;
  long int D.19194;
  long int D.19195;
  struct MonoAssembly * D.19200;
  int D.19207;
  const char * D.19208;
  const char * D.19209;
  _Bool D.19215;
  long int D.19216;
  long int D.19217;
  struct MonoAssembly * reference;
  struct MonoAssemblyName aname;
  MonoImageOpenStatus status;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.19066>; else goto <D.19067>;
        <D.19066>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.19067>:
        D.19068 = ret != 0;
        D.19069 = (long int) D.19068;
        D.19070 = __builtin_expect (D.19069, 0);
        if (D.19070 != 0) goto <D.19071>; else goto <D.19072>;
        <D.19071>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1074, "ret == 0");
        <D.19072>:
      }
      D.19073 = image->references;
      if (D.19073 == 0B) goto <D.19074>; else goto <D.19075>;
      <D.19074>:
      {
        struct MonoTableInfo * t;

        t = &image->tables[35];
        D.19076 = t->rows;
        D.19077 = (int) D.19076;
        D.19078 = D.19077 + 1;
        D.19079 = (long unsigned int) D.19078;
        D.19080 = D.19079 * 8;
        D.19081 = monoeg_malloc0 (D.19080);
        image->references = D.19081;
        D.19076 = t->rows;
        D.19077 = (int) D.19076;
        image->nreferences = D.19077;
      }
      <D.19075>:
      D.19073 = image->references;
      D.19082 = (long unsigned int) index;
      D.19083 = D.19082 * 8;
      D.19084 = D.19073 + D.19083;
      reference = *D.19084;
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.19085>; else goto <D.19086>;
        <D.19085>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.19086>:
        D.19087 = ret != 0;
        D.19088 = (long int) D.19087;
        D.19089 = __builtin_expect (D.19088, 0);
        if (D.19089 != 0) goto <D.19090>; else goto <D.19091>;
        <D.19090>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1082, "ret == 0");
        <D.19091>:
      }
      if (reference != 0B) goto <D.19092>; else goto <D.19093>;
      <D.19092>:
      return;
      <D.19093>:
      mono_assembly_get_assemblyref (image, index, &aname);
      D.19096 = image->assembly;
      if (D.19096 != 0B) goto <D.19097>; else goto <D.19094>;
      <D.19097>:
      D.19096 = image->assembly;
      D.19098 = D.19096->ref_only;
      if (D.19098 != 0) goto <D.19099>; else goto <D.19094>;
      <D.19099>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.19101>; else goto <D.19102>;
        <D.19101>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = aname.name;
          D.19103 = "mscorlib";
          D.19104 = MEM[(const unsigned char *)D.19103];
          D.19105 = (int) D.19104;
          D.19106 = *__s2;
          D.19107 = (int) D.19106;
          __result = D.19105 - D.19107;
          {
            D.19108 = __s2_len != 0;
            D.19109 = __result == 0;
            D.19110 = D.19108 & D.19109;
            if (D.19110 != 0) goto <D.19111>; else goto <D.19112>;
            <D.19111>:
            D.19113 = &MEM[(void *)"mscorlib" + 1B];
            D.19114 = *D.19113;
            D.19115 = (int) D.19114;
            D.19116 = __s2 + 1;
            D.19117 = *D.19116;
            D.19118 = (int) D.19117;
            __result = D.19115 - D.19118;
            D.19119 = __s2_len > 1;
            D.19109 = __result == 0;
            D.19120 = D.19119 & D.19109;
            if (D.19120 != 0) goto <D.19121>; else goto <D.19122>;
            <D.19121>:
            D.19123 = &MEM[(void *)"mscorlib" + 2B];
            D.19124 = *D.19123;
            D.19125 = (int) D.19124;
            D.19126 = __s2 + 2;
            D.19127 = *D.19126;
            D.19128 = (int) D.19127;
            __result = D.19125 - D.19128;
            D.19129 = __s2_len > 2;
            D.19109 = __result == 0;
            D.19130 = D.19129 & D.19109;
            if (D.19130 != 0) goto <D.19131>; else goto <D.19132>;
            <D.19131>:
            D.19133 = &MEM[(void *)"mscorlib" + 3B];
            D.19134 = *D.19133;
            D.19135 = (int) D.19134;
            D.19136 = __s2 + 3;
            D.19137 = *D.19136;
            D.19138 = (int) D.19137;
            __result = D.19135 - D.19138;
            <D.19132>:
            <D.19122>:
            <D.19112>:
          }
          D.17643 = __result;
        }
        iftmp.24 = -D.17643;
        goto <D.19139>;
        <D.19102>:
        D.19140 = aname.name;
        iftmp.24 = __builtin_strcmp (D.19140, "mscorlib");
        <D.19139>:
        D.17644 = iftmp.24;
      }
      if (D.17644 == 0) goto <D.19141>; else goto <D.19142>;
      <D.19141>:
      D.19096 = image->assembly;
      D.19143 = D.19096->basedir;
      reference = mono_assembly_load_full (&aname, D.19143, &status, 0);
      goto <D.19144>;
      <D.19142>:
      reference = mono_assembly_loaded_full (&aname, 1);
      if (reference == 0B) goto <D.19145>; else goto <D.19146>;
      <D.19145>:
      reference = mono_assembly_invoke_search_hook_internal (&aname, 1, 1);
      <D.19146>:
      <D.19144>:
      if (reference == 0B) goto <D.19147>; else goto <D.19148>;
      <D.19147>:
      reference = -1B;
      <D.19148>:
      goto <D.19095>;
      <D.19094>:
      D.19096 = image->assembly;
      if (D.19096 != 0B) goto <D.19150>; else goto <D.19151>;
      <D.19150>:
      D.19096 = image->assembly;
      iftmp.25 = D.19096->basedir;
      goto <D.19152>;
      <D.19151>:
      iftmp.25 = 0B;
      <D.19152>:
      reference = mono_assembly_load (&aname, iftmp.25, &status);
      <D.19095>:
      if (reference == 0B) goto <D.19153>; else goto <D.19154>;
      <D.19153>:
      {
        char * extra_msg;

        status.26 = status;
        if (status.26 == 1) goto <D.19158>; else goto <D.19155>;
        <D.19158>:
        D.19159 = __errno_location ();
        D.19160 = *D.19159;
        if (D.19160 == 2) goto <D.19161>; else goto <D.19155>;
        <D.19161>:
        D.19096 = image->assembly;
        if (D.19096 != 0B) goto <D.19163>; else goto <D.19164>;
        <D.19163>:
        D.19096 = image->assembly;
        iftmp.27 = D.19096->basedir;
        goto <D.19165>;
        <D.19164>:
        iftmp.27 = "";
        <D.19165>:
        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.27);
        goto <D.19156>;
        <D.19155>:
        status.26 = status;
        if (status.26 == 1) goto <D.19166>; else goto <D.19167>;
        <D.19166>:
        D.19159 = __errno_location ();
        D.19160 = *D.19159;
        D.19168 = strerror (D.19160);
        extra_msg = monoeg_g_strdup_printf ("System error: %s\n", D.19168);
        goto <D.19169>;
        <D.19167>:
        status.26 = status;
        if (status.26 == 2) goto <D.19170>; else goto <D.19171>;
        <D.19170>:
        extra_msg = monoeg_strdup ("Cannot find an assembly referenced from this one.\n");
        goto <D.19172>;
        <D.19171>:
        status.26 = status;
        if (status.26 == 3) goto <D.19173>; else goto <D.19174>;
        <D.19173>:
        extra_msg = monoeg_strdup ("The file exists but is not a valid assembly.\n");
        goto <D.19175>;
        <D.19174>:
        extra_msg = monoeg_strdup ("");
        <D.19175>:
        <D.19172>:
        <D.19169>:
        <D.19156>:
        D.19177 = &aname.public_key_token;
        D.19178 = MEM[(const char *)D.19177];
        if (D.19178 != 0) goto <D.19179>; else goto <D.19180>;
        <D.19179>:
        iftmp.28 = &aname.public_key_token;
        goto <D.19181>;
        <D.19180>:
        iftmp.28 = "(none)";
        <D.19181>:
        D.19182 = aname.revision;
        D.19183 = (int) D.19182;
        D.19184 = aname.build;
        D.19185 = (int) D.19184;
        D.19186 = aname.minor;
        D.19187 = (int) D.19186;
        D.19188 = aname.major;
        D.19189 = (int) D.19188;
        D.19140 = aname.name;
        D.19190 = image->name;
        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.19190, D.19140, index, D.19189, D.19187, D.19185, D.19183, iftmp.28, extra_msg);
        monoeg_g_free (extra_msg);
      }
      <D.19154>:
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.19191>; else goto <D.19192>;
        <D.19191>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.19192>:
        D.19193 = ret != 0;
        D.19194 = (long int) D.19193;
        D.19195 = __builtin_expect (D.19194, 0);
        if (D.19195 != 0) goto <D.19196>; else goto <D.19197>;
        <D.19196>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1133, "ret == 0");
        <D.19197>:
      }
      if (reference == 0B) goto <D.19198>; else goto <D.19199>;
      <D.19198>:
      reference = -1B;
      <D.19199>:
      D.19073 = image->references;
      D.19082 = (long unsigned int) index;
      D.19083 = D.19082 * 8;
      D.19084 = D.19073 + D.19083;
      D.19200 = *D.19084;
      if (D.19200 == 0B) goto <D.19201>; else goto <D.19202>;
      <D.19201>:
      if (reference != -1B) goto <D.19203>; else goto <D.19204>;
      <D.19203>:
      mono_assembly_addref (reference);
      D.19096 = image->assembly;
      if (D.19096 != 0B) goto <D.19205>; else goto <D.19206>;
      <D.19205>:
      D.19207 = reference->ref_count;
      D.19208 = reference->aname.name;
      D.19096 = image->assembly;
      D.19096 = image->assembly;
      D.19209 = D.19096->aname.name;
      mono_trace (64, 1, "Assembly Ref addref %s[%p] -> %s[%p]: %d", D.19209, D.19096, D.19208, reference, D.19207);
      <D.19206>:
      goto <D.19210>;
      <D.19204>:
      D.19096 = image->assembly;
      if (D.19096 != 0B) goto <D.19211>; else goto <D.19212>;
      <D.19211>:
      D.19096 = image->assembly;
      D.19096 = image->assembly;
      D.19209 = D.19096->aname.name;
      mono_trace (64, 1, "Failed to load assembly %s[%p]\n", D.19209, D.19096);
      <D.19212>:
      <D.19210>:
      D.19073 = image->references;
      D.19082 = (long unsigned int) index;
      D.19083 = D.19082 * 8;
      D.19084 = D.19073 + D.19083;
      *D.19084 = reference;
      <D.19202>:
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.19213>; else goto <D.19214>;
        <D.19213>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.19214>:
        D.19215 = ret != 0;
        D.19216 = (long int) D.19215;
        D.19217 = __builtin_expect (D.19216, 0);
        if (D.19217 != 0) goto <D.19218>; else goto <D.19219>;
        <D.19218>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1153, "ret == 0");
        <D.19219>:
      }
      D.19073 = image->references;
      D.19082 = (long unsigned int) index;
      D.19083 = D.19082 * 8;
      D.19084 = D.19073 + D.19083;
      D.19200 = *D.19084;
      if (D.19200 != reference) goto <D.19220>; else goto <D.19221>;
      <D.19220>:
      mono_assembly_close (reference);
      <D.19221>:
    }
  finally
    {
      aname = {CLOBBER};
      status = {CLOBBER};
    }
}


mono_assembly_invoke_search_hook_internal (struct MonoAssemblyName * aname, gboolean refonly, gboolean postload)
{
  int D.19225;
  int D.19228;
  struct MonoAssembly * (*<Tf27>) (struct MonoAssemblyName *, void *) D.19231;
  void * D.19232;
  struct MonoAssembly * D.19235;
  struct AssemblySearchHook * hook;

  hook = assembly_search_hook;
  goto <D.17694>;
  <D.17693>:
  D.19225 = hook->refonly;
  if (D.19225 == refonly) goto <D.19226>; else goto <D.19227>;
  <D.19226>:
  D.19228 = hook->postload;
  if (D.19228 == postload) goto <D.19229>; else goto <D.19230>;
  <D.19229>:
  {
    struct MonoAssembly * ass;

    D.19231 = hook->func;
    D.19232 = hook->user_data;
    ass = D.19231 (aname, D.19232);
    if (ass != 0B) goto <D.19233>; else goto <D.19234>;
    <D.19233>:
    D.19235 = ass;
    return D.19235;
    <D.19234>:
  }
  <D.19230>:
  <D.19227>:
  hook = hook->next;
  <D.17694>:
  if (hook != 0B) goto <D.17693>; else goto <D.17695>;
  <D.17695>:
  D.19235 = 0B;
  return D.19235;
}


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


mono_assembly_invoke_load_hook (struct MonoAssembly * ass)
{
  void (*<Tf20>) (struct MonoAssembly *, void *) D.19237;
  void * D.19238;
  struct AssemblyLoadHook * hook;

  hook = assembly_load_hook;
  goto <D.17663>;
  <D.17662>:
  D.19237 = hook->func;
  D.19238 = hook->user_data;
  D.19237 (ass, D.19238);
  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.29;
  struct AssemblyLoadHook * hook;

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


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

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


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.30;
  struct AssemblySearchHook * hook;

  if (func == 0B) goto <D.19245>; else goto <D.19246>;
  <D.19245>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1250, "func != NULL");
  return;
  <D.19246>:
  hook = monoeg_malloc0 (32);
  hook->func = func;
  hook->user_data = user_data;
  hook->refonly = refonly;
  hook->postload = postload;
  assembly_search_hook.30 = assembly_search_hook;
  hook->next = assembly_search_hook.30;
  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.31;
  struct AssemblyPreLoadHook * hook;

  if (func == 0B) goto <D.19249>; else goto <D.19250>;
  <D.19249>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1341, "func != NULL");
  return;
  <D.19250>:
  hook = monoeg_malloc0 (24);
  hook->func = func;
  hook->user_data = user_data;
  assembly_preload_hook.31 = assembly_preload_hook;
  hook->next = assembly_preload_hook.31;
  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.32;
  struct AssemblyPreLoadHook * hook;

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


mono_assembly_open_from_bundle (const char * filename, MonoImageOpenStatus * status, gboolean refonly)
{
  const struct MonoBundledAssembly * * bundles.33;
  struct MonoImage * D.19260;
  _Bool D.19263;
  long int D.19264;
  long int D.19265;
  int D.17830;
  long unsigned int D.19268;
  long unsigned int D.19269;
  const struct MonoBundledAssembly * * D.19270;
  const struct MonoBundledAssembly * D.19271;
  const char * D.19272;
  unsigned int D.19275;
  const unsigned char * D.19276;
  _Bool D.19280;
  long int D.19281;
  long int D.19282;
  int i;
  char * name;
  struct MonoImage * image;

  image = 0B;
  bundles.33 = bundles;
  if (bundles.33 == 0B) goto <D.19258>; else goto <D.19259>;
  <D.19258>:
  D.19260 = 0B;
  return D.19260;
  <D.19259>:
  name = monoeg_g_path_get_basename (filename);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19261>; else goto <D.19262>;
    <D.19261>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19262>:
    D.19263 = ret != 0;
    D.19264 = (long int) D.19263;
    D.19265 = __builtin_expect (D.19264, 0);
    if (D.19265 != 0) goto <D.19266>; else goto <D.19267>;
    <D.19266>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1466, "ret == 0");
    <D.19267>:
  }
  i = 0;
  goto <D.17833>;
  <D.17832>:
  {
    size_t __s1_len;
    size_t __s2_len;

    bundles.33 = bundles;
    D.19268 = (long unsigned int) i;
    D.19269 = D.19268 * 8;
    D.19270 = bundles.33 + D.19269;
    D.19271 = *D.19270;
    D.19272 = D.19271->name;
    D.17830 = __builtin_strcmp (D.19272, name);
  }
  if (D.17830 == 0) goto <D.19273>; else goto <D.19274>;
  <D.19273>:
  bundles.33 = bundles;
  D.19268 = (long unsigned int) i;
  D.19269 = D.19268 * 8;
  D.19270 = bundles.33 + D.19269;
  D.19271 = *D.19270;
  D.19275 = D.19271->size;
  bundles.33 = bundles;
  D.19268 = (long unsigned int) i;
  D.19269 = D.19268 * 8;
  D.19270 = bundles.33 + D.19269;
  D.19271 = *D.19270;
  D.19276 = D.19271->data;
  image = mono_image_open_from_data_with_name (D.19276, D.19275, 0, status, refonly, name);
  goto <D.17831>;
  <D.19274>:
  i = i + 1;
  <D.17833>:
  if (image == 0B) goto <D.19277>; else goto <D.17831>;
  <D.19277>:
  bundles.33 = bundles;
  D.19268 = (long unsigned int) i;
  D.19269 = D.19268 * 8;
  D.19270 = bundles.33 + D.19269;
  D.19271 = *D.19270;
  if (D.19271 != 0B) goto <D.17832>; else goto <D.17831>;
  <D.17831>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19278>; else goto <D.19279>;
    <D.19278>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19279>:
    D.19280 = ret != 0;
    D.19281 = (long int) D.19280;
    D.19282 = __builtin_expect (D.19281, 0);
    if (D.19282 != 0) goto <D.19283>; else goto <D.19284>;
    <D.19283>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1473, "ret == 0");
    <D.19284>:
  }
  monoeg_g_free (name);
  if (image != 0B) goto <D.19285>; else goto <D.19286>;
  <D.19285>:
  mono_image_addref (image);
  D.19260 = image;
  return D.19260;
  <D.19286>:
  D.19260 = 0B;
  return D.19260;
}


mono_assembly_open_full (const char * filename, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.19290;
  int D.19293;
  gchar * D.19296;
  char D.19297;
  struct GError * error.34;
  gchar * D.19305;
  unsigned char D.19307;
  _Bool D.19310;
  _Bool D.19311;
  _Bool D.19312;
  const struct MonoBundledAssembly * * bundles.35;
  <unnamed type> D.19322;
  struct MonoAssembly * D.19325;
  struct MonoImage * D.19332;
  struct MonoImage * image;
  struct MonoAssembly * ass;
  MonoImageOpenStatus def_status;
  gchar * fname;
  gchar * new_fname;

  try
    {
      if (filename == 0B) goto <D.19288>; else goto <D.19289>;
      <D.19288>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1491, "filename != NULL");
      D.19290 = 0B;
      return D.19290;
      <D.19289>:
      if (status == 0B) goto <D.19291>; else goto <D.19292>;
      <D.19291>:
      status = &def_status;
      <D.19292>:
      *status = 0;
      D.19293 = strncmp (filename, "file://", 7);
      if (D.19293 == 0) goto <D.19294>; else goto <D.19295>;
      <D.19294>:
      {
        struct GError * error;
        gchar * uri;
        gchar * tmpuri;

        try
          {
            error = 0B;
            uri = filename;
            D.19296 = uri + 7;
            D.19297 = *D.19296;
            if (D.19297 != 47) goto <D.19298>; else goto <D.19299>;
            <D.19298>:
            D.19296 = uri + 7;
            uri = monoeg_g_strdup_printf ("file:///%s", D.19296);
            <D.19299>:
            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.19300>; else goto <D.19301>;
            <D.19300>:
            monoeg_g_free (tmpuri);
            <D.19301>:
            error.34 = error;
            if (error.34 != 0B) goto <D.19303>; else goto <D.19304>;
            <D.19303>:
            error.34 = error;
            D.19305 = error.34->message;
            monoeg_g_log (0B, 16, "%s\n", D.19305);
            error.34 = error;
            monoeg_g_error_free (error.34);
            fname = monoeg_strdup (filename);
            <D.19304>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      goto <D.19306>;
      <D.19295>:
      fname = monoeg_strdup (filename);
      <D.19306>:
      mono_trace (64, 1, "Assembly Loader probing location: \'%s\'.", fname);
      new_fname = 0B;
      D.19307 = mono_assembly_is_in_gac (fname);
      if (D.19307 == 0) goto <D.19308>; else goto <D.19309>;
      <D.19308>:
      new_fname = mono_make_shadow_copy (fname);
      <D.19309>:
      D.19310 = new_fname != 0B;
      D.19311 = new_fname != fname;
      D.19312 = D.19310 & D.19311;
      if (D.19312 != 0) goto <D.19313>; else goto <D.19314>;
      <D.19313>:
      monoeg_g_free (fname);
      fname = new_fname;
      mono_trace (64, 1, "Assembly Loader shadow-copied assembly to: \'%s\'.", fname);
      <D.19314>:
      image = 0B;
      bundles.35 = bundles;
      if (bundles.35 != 0B) goto <D.19316>; else goto <D.19317>;
      <D.19316>:
      image = mono_assembly_open_from_bundle (fname, status, refonly);
      <D.19317>:
      if (image == 0B) goto <D.19318>; else goto <D.19319>;
      <D.19318>:
      image = mono_image_open_full (fname, status, refonly);
      <D.19319>:
      if (image == 0B) goto <D.19320>; else goto <D.19321>;
      <D.19320>:
      D.19322 = *status;
      if (D.19322 == 0) goto <D.19323>; else goto <D.19324>;
      <D.19323>:
      *status = 1;
      <D.19324>:
      monoeg_g_free (fname);
      D.19290 = 0B;
      return D.19290;
      <D.19321>:
      D.19325 = image->assembly;
      if (D.19325 != 0B) goto <D.19326>; else goto <D.19327>;
      <D.19326>:
      D.19325 = image->assembly;
      mono_assembly_invoke_load_hook (D.19325);
      mono_image_close (image);
      monoeg_g_free (fname);
      D.19290 = image->assembly;
      return D.19290;
      <D.19327>:
      ass = mono_assembly_load_from_full (image, fname, status, refonly);
      if (ass != 0B) goto <D.19328>; else goto <D.19329>;
      <D.19328>:
      mono_trace (64, 1, "Assembly Loader loaded assembly from location: \'%s\'.", filename);
      if (refonly == 0) goto <D.19330>; else goto <D.19331>;
      <D.19330>:
      D.19332 = ass->image;
      mono_config_for_assembly (D.19332);
      <D.19331>:
      <D.19329>:
      mono_image_close (image);
      monoeg_g_free (fname);
      D.19290 = ass;
      return D.19290;
    }
  finally
    {
      def_status = {CLOBBER};
    }
}


mono_assembly_is_in_gac (const gchar * filename)
{
  MonoBoolean D.19337;
  gchar * D.19338;
  char * D.19339;
  long unsigned int D.19342;
  char D.19343;
  int D.19346;
  int D.19351;
  int D.19356;
  char * D.19362;
  long unsigned int D.19365;
  int D.19368;
  int D.19373;
  const gchar * rootdir;
  gchar * gp;
  gchar * * paths;

  if (filename == 0B) goto <D.19335>; else goto <D.19336>;
  <D.19335>:
  D.19337 = 0;
  return D.19337;
  <D.19336>:
  paths = extra_gac_paths;
  goto <D.18138>;
  <D.18137>:
  D.19338 = *paths;
  D.19339 = strstr (D.19338, filename);
  D.19338 = *paths;
  if (D.19339 != D.19338) goto <D.19340>; else goto <D.19341>;
  <D.19340>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19341>:
  D.19338 = *paths;
  D.19342 = strlen (D.19338);
  gp = filename + D.19342;
  D.19343 = *gp;
  if (D.19343 != 47) goto <D.19344>; else goto <D.19345>;
  <D.19344>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19345>:
  gp = gp + 1;
  D.19346 = strncmp (gp, "lib", 3);
  if (D.19346 != 0) goto <D.19347>; else goto <D.19348>;
  <D.19347>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19348>:
  gp = gp + 3;
  D.19343 = *gp;
  if (D.19343 != 47) goto <D.19349>; else goto <D.19350>;
  <D.19349>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19350>:
  gp = gp + 1;
  D.19351 = strncmp (gp, "mono", 4);
  if (D.19351 != 0) goto <D.19352>; else goto <D.19353>;
  <D.19352>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19353>:
  gp = gp + 4;
  D.19343 = *gp;
  if (D.19343 != 47) goto <D.19354>; else goto <D.19355>;
  <D.19354>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19355>:
  gp = gp + 1;
  D.19356 = strncmp (gp, "gac", 3);
  if (D.19356 != 0) goto <D.19357>; else goto <D.19358>;
  <D.19357>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19358>:
  gp = gp + 3;
  D.19343 = *gp;
  if (D.19343 != 47) goto <D.19359>; else goto <D.19360>;
  <D.19359>:
  // predicted unlikely by continue predictor.
  goto <D.18109>;
  <D.19360>:
  D.19337 = 1;
  return D.19337;
  <D.18109>:
  paths = paths + 8;
  <D.18138>:
  if (paths != 0B) goto <D.19361>; else goto <D.18139>;
  <D.19361>:
  D.19338 = *paths;
  if (D.19338 != 0B) goto <D.18137>; else goto <D.18139>;
  <D.18139>:
  rootdir = mono_assembly_getrootdir ();
  D.19362 = strstr (filename, rootdir);
  if (D.19362 != filename) goto <D.19363>; else goto <D.19364>;
  <D.19363>:
  D.19337 = 0;
  return D.19337;
  <D.19364>:
  D.19365 = strlen (rootdir);
  gp = filename + D.19365;
  D.19343 = *gp;
  if (D.19343 != 47) goto <D.19366>; else goto <D.19367>;
  <D.19366>:
  D.19337 = 0;
  return D.19337;
  <D.19367>:
  gp = gp + 1;
  D.19368 = strncmp (gp, "mono", 4);
  if (D.19368 != 0) goto <D.19369>; else goto <D.19370>;
  <D.19369>:
  D.19337 = 0;
  return D.19337;
  <D.19370>:
  gp = gp + 4;
  D.19343 = *gp;
  if (D.19343 != 47) goto <D.19371>; else goto <D.19372>;
  <D.19371>:
  D.19337 = 0;
  return D.19337;
  <D.19372>:
  gp = gp + 1;
  D.19373 = strncmp (gp, "gac", 3);
  if (D.19373 != 0) goto <D.19374>; else goto <D.19375>;
  <D.19374>:
  D.19337 = 0;
  return D.19337;
  <D.19375>:
  gp = gp + 3;
  D.19343 = *gp;
  if (D.19343 != 47) goto <D.19376>; else goto <D.19377>;
  <D.19376>:
  D.19337 = 0;
  return D.19337;
  <D.19377>:
  D.19337 = 1;
  return D.19337;
}


mono_assembly_load_friends (struct MonoAssembly * ass)
{
  unsigned char D.19379;
  _Bool D.19386;
  long int D.19387;
  long int D.19388;
  _Bool D.19393;
  long int D.19394;
  long int D.19395;
  _Bool D.19400;
  long int D.19401;
  long int D.19402;
  _Bool D.19409;
  long int D.19410;
  long int D.19411;
  _Bool D.19416;
  long int D.19417;
  long int D.19418;
  struct MonoMethod * D.19423;
  struct MonoClass * D.19425;
  struct MonoClass * D.19426;
  unsigned int D.19427;
  const mono_byte * data.36;
  const gchar * data.37;
  char D.19434;
  const gchar * D.19436;
  char D.19437;
  const gchar * D.19439;
  char D.19440;
  int D.19441;
  int D.19442;
  const char * D.19443;
  int D.19444;
  int D.19448;
  _Bool D.19451;
  long int D.19452;
  long int D.19453;
  _Bool D.19460;
  long int D.19461;
  long int D.19462;
  _Bool D.19467;
  long int D.19468;
  long int D.19469;
  int i;
  struct MonoCustomAttrInfo * attrs;
  struct GSList * list;

  D.19379 = ass->friend_assembly_names_inited;
  if (D.19379 != 0) goto <D.19380>; else goto <D.19381>;
  <D.19380>:
  return;
  <D.19381>:
  attrs = mono_custom_attrs_from_assembly (ass);
  if (attrs == 0B) goto <D.19382>; else goto <D.19383>;
  <D.19382>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19384>; else goto <D.19385>;
    <D.19384>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19385>:
    D.19386 = ret != 0;
    D.19387 = (long int) D.19386;
    D.19388 = __builtin_expect (D.19387, 0);
    if (D.19388 != 0) goto <D.19389>; else goto <D.19390>;
    <D.19389>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1611, "ret == 0");
    <D.19390>:
  }
  ass->friend_assembly_names_inited = 1;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19391>; else goto <D.19392>;
    <D.19391>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19392>:
    D.19393 = ret != 0;
    D.19394 = (long int) D.19393;
    D.19395 = __builtin_expect (D.19394, 0);
    if (D.19395 != 0) goto <D.19396>; else goto <D.19397>;
    <D.19396>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1613, "ret == 0");
    <D.19397>:
  }
  return;
  <D.19383>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19398>; else goto <D.19399>;
    <D.19398>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19399>:
    D.19400 = ret != 0;
    D.19401 = (long int) D.19400;
    D.19402 = __builtin_expect (D.19401, 0);
    if (D.19402 != 0) goto <D.19403>; else goto <D.19404>;
    <D.19403>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1617, "ret == 0");
    <D.19404>:
  }
  D.19379 = ass->friend_assembly_names_inited;
  if (D.19379 != 0) goto <D.19405>; else goto <D.19406>;
  <D.19405>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19407>; else goto <D.19408>;
    <D.19407>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19408>:
    D.19409 = ret != 0;
    D.19410 = (long int) D.19409;
    D.19411 = __builtin_expect (D.19410, 0);
    if (D.19411 != 0) goto <D.19412>; else goto <D.19413>;
    <D.19412>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1619, "ret == 0");
    <D.19413>:
  }
  return;
  <D.19406>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19414>; else goto <D.19415>;
    <D.19414>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19415>:
    D.19416 = ret != 0;
    D.19417 = (long int) D.19416;
    D.19418 = __builtin_expect (D.19417, 0);
    if (D.19418 != 0) goto <D.19419>; else goto <D.19420>;
    <D.19419>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1622, "ret == 0");
    <D.19420>:
  }
  list = 0B;
  i = 0;
  goto <D.17878>;
  <D.17877>:
  {
    struct MonoCustomAttrEntry * attr;
    struct MonoAssemblyName * aname;
    const gchar * data;
    guint slen;

    try
      {
        attr = &attrs->attrs[i];
        D.19423 = attr->ctor;
        if (D.19423 == 0B) goto <D.19421>; else goto <D.19424>;
        <D.19424>:
        D.19423 = attr->ctor;
        D.19425 = D.19423->klass;
        D.19426 = mono_defaults.internals_visible_class;
        if (D.19425 != D.19426) goto <D.19421>; else goto <D.19422>;
        <D.19421>:
        // predicted unlikely by continue predictor.
        goto <D.17876>;
        <D.19422>:
        D.19427 = attr->data_size;
        if (D.19427 <= 3) goto <D.19428>; else goto <D.19429>;
        <D.19428>:
        // predicted unlikely by continue predictor.
        goto <D.17876>;
        <D.19429>:
        data.36 = attr->data;
        data = data.36;
        data.37 = data;
        D.19434 = *data.37;
        if (D.19434 != 1) goto <D.19431>; else goto <D.19435>;
        <D.19435>:
        data.37 = data;
        D.19436 = data.37 + 1;
        D.19437 = *D.19436;
        if (D.19437 != 0) goto <D.19431>; else goto <D.19438>;
        <D.19438>:
        data.37 = data;
        D.19439 = data.37 + 2;
        D.19440 = *D.19439;
        D.19441 = (int) D.19440;
        D.19442 = D.19441 & 255;
        if (D.19442 == 255) goto <D.19431>; else goto <D.19432>;
        <D.19431>:
        // predicted unlikely by continue predictor.
        goto <D.17876>;
        <D.19432>:
        data.37 = data;
        D.19443 = data.37 + 2;
        slen = mono_metadata_decode_value (D.19443, &data);
        aname = monoeg_malloc0 (80);
        data.37 = data;
        D.19444 = mono_assembly_name_parse_full (data.37, aname, 1, 0B, 0B);
        if (D.19444 != 0) goto <D.19445>; else goto <D.19446>;
        <D.19445>:
        list = monoeg_g_slist_prepend (list, aname);
        goto <D.19447>;
        <D.19446>:
        monoeg_g_free (aname);
        <D.19447>:
      }
    finally
      {
        data = {CLOBBER};
      }
  }
  <D.17876>:
  i = i + 1;
  <D.17878>:
  D.19448 = attrs->num_attrs;
  if (D.19448 > i) goto <D.17877>; else goto <D.17879>;
  <D.17879>:
  mono_custom_attrs_free (attrs);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19449>; else goto <D.19450>;
    <D.19449>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19450>:
    D.19451 = ret != 0;
    D.19452 = (long int) D.19451;
    D.19453 = __builtin_expect (D.19452, 0);
    if (D.19453 != 0) goto <D.19454>; else goto <D.19455>;
    <D.19454>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1654, "ret == 0");
    <D.19455>:
  }
  D.19379 = ass->friend_assembly_names_inited;
  if (D.19379 != 0) goto <D.19456>; else goto <D.19457>;
  <D.19456>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19458>; else goto <D.19459>;
    <D.19458>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19459>:
    D.19460 = ret != 0;
    D.19461 = (long int) D.19460;
    D.19462 = __builtin_expect (D.19461, 0);
    if (D.19462 != 0) goto <D.19463>; else goto <D.19464>;
    <D.19463>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1656, "ret == 0");
    <D.19464>:
  }
  monoeg_g_slist_foreach (list, free_item, 0B);
  monoeg_g_slist_free (list);
  return;
  <D.19457>:
  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.19465>; else goto <D.19466>;
    <D.19465>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19466>:
    D.19467 = ret != 0;
    D.19468 = (long int) D.19467;
    D.19469 = __builtin_expect (D.19468, 0);
    if (D.19469 != 0) goto <D.19470>; else goto <D.19471>;
    <D.19470>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1666, "ret == 0");
    <D.19471>:
  }
}


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.19475;

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


mono_assembly_load_from_full (struct MonoImage * image, const char * fname, MonoImageOpenStatus * status, gboolean refonly)
{
  unsigned int D.19477;
  unsigned int D.19478;
  struct MonoAssembly * D.19481;
  struct MonoAssemblyName * D.19482;
  struct MonoImage * D.19483;
  int D.17904;
  int iftmp.38;
  int D.17903;
  const char[9] * D.19489;
  unsigned char D.19490;
  int D.19491;
  unsigned char D.19492;
  int D.19493;
  _Bool D.19494;
  _Bool D.19495;
  _Bool D.19496;
  const unsigned char * D.19499;
  unsigned char D.19500;
  int D.19501;
  const unsigned char * D.19502;
  unsigned char D.19503;
  int D.19504;
  _Bool D.19505;
  _Bool D.19506;
  const unsigned char * D.19509;
  unsigned char D.19510;
  int D.19511;
  const unsigned char * D.19512;
  unsigned char D.19513;
  int D.19514;
  _Bool D.19515;
  _Bool D.19516;
  const unsigned char * D.19519;
  unsigned char D.19520;
  int D.19521;
  const unsigned char * D.19522;
  unsigned char D.19523;
  int D.19524;
  const char * D.19526;
  int D.19529;
  char * D.19530;
  _Bool D.19537;
  long int D.19538;
  long int D.19539;
  struct MonoAssembly * D.19542;
  _Bool D.19547;
  long int D.19548;
  long int D.19549;
  struct GList * loaded_assemblies.39;
  struct GList * loaded_assemblies.40;
  _Bool D.19556;
  long int D.19557;
  long int D.19558;
  struct MonoAssembly * ass;
  struct MonoAssembly * ass2;
  char * base_dir;

  D.19477 = BIT_FIELD_REF <*image, 32, 5696>;
  D.19478 = D.19477 & 16777215;
  if (D.19478 == 0) goto <D.19479>; else goto <D.19480>;
  <D.19479>:
  *status = 3;
  D.19481 = 0B;
  return D.19481;
  <D.19480>:
  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.19482 = &ass->aname;
  mono_assembly_fill_assembly_name (image, D.19482);
  D.19483 = mono_defaults.corlib;
  if (D.19483 != 0B) goto <D.19484>; else goto <D.19485>;
  <D.19484>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 8;
    if (__s2_len <= 3) goto <D.19487>; else goto <D.19488>;
    <D.19487>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = ass->aname.name;
      D.19489 = "mscorlib";
      D.19490 = MEM[(const unsigned char *)D.19489];
      D.19491 = (int) D.19490;
      D.19492 = *__s2;
      D.19493 = (int) D.19492;
      __result = D.19491 - D.19493;
      {
        D.19494 = __s2_len != 0;
        D.19495 = __result == 0;
        D.19496 = D.19494 & D.19495;
        if (D.19496 != 0) goto <D.19497>; else goto <D.19498>;
        <D.19497>:
        D.19499 = &MEM[(void *)"mscorlib" + 1B];
        D.19500 = *D.19499;
        D.19501 = (int) D.19500;
        D.19502 = __s2 + 1;
        D.19503 = *D.19502;
        D.19504 = (int) D.19503;
        __result = D.19501 - D.19504;
        D.19505 = __s2_len > 1;
        D.19495 = __result == 0;
        D.19506 = D.19505 & D.19495;
        if (D.19506 != 0) goto <D.19507>; else goto <D.19508>;
        <D.19507>:
        D.19509 = &MEM[(void *)"mscorlib" + 2B];
        D.19510 = *D.19509;
        D.19511 = (int) D.19510;
        D.19512 = __s2 + 2;
        D.19513 = *D.19512;
        D.19514 = (int) D.19513;
        __result = D.19511 - D.19514;
        D.19515 = __s2_len > 2;
        D.19495 = __result == 0;
        D.19516 = D.19515 & D.19495;
        if (D.19516 != 0) goto <D.19517>; else goto <D.19518>;
        <D.19517>:
        D.19519 = &MEM[(void *)"mscorlib" + 3B];
        D.19520 = *D.19519;
        D.19521 = (int) D.19520;
        D.19522 = __s2 + 3;
        D.19523 = *D.19522;
        D.19524 = (int) D.19523;
        __result = D.19521 - D.19524;
        <D.19518>:
        <D.19508>:
        <D.19498>:
      }
      D.17903 = __result;
    }
    iftmp.38 = -D.17903;
    goto <D.19525>;
    <D.19488>:
    D.19526 = ass->aname.name;
    iftmp.38 = __builtin_strcmp (D.19526, "mscorlib");
    <D.19525>:
    D.17904 = iftmp.38;
  }
  if (D.17904 == 0) goto <D.19527>; else goto <D.19528>;
  <D.19527>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  D.19483 = mono_defaults.corlib;
  mono_image_addref (D.19483);
  *status = 0;
  D.19483 = mono_defaults.corlib;
  D.19481 = D.19483->assembly;
  return D.19481;
  <D.19528>:
  <D.19485>:
  mono_image_addref (image);
  D.19529 = image->ref_count;
  D.19530 = image->name;
  D.19526 = ass->aname.name;
  mono_trace (64, 1, "Image addref %s[%p] -> %s[%p]: %d", D.19526, ass, D.19530, image, D.19529);
  D.19526 = ass->aname.name;
  if (D.19526 != 0B) goto <D.19531>; else goto <D.19532>;
  <D.19531>:
  D.19482 = &ass->aname;
  ass2 = mono_assembly_invoke_search_hook_internal (D.19482, refonly, 0);
  if (ass2 != 0B) goto <D.19533>; else goto <D.19534>;
  <D.19533>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.19481 = ass2;
  return D.19481;
  <D.19534>:
  <D.19532>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19535>; else goto <D.19536>;
    <D.19535>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19536>:
    D.19537 = ret != 0;
    D.19538 = (long int) D.19537;
    D.19539 = __builtin_expect (D.19538, 0);
    if (D.19539 != 0) goto <D.19540>; else goto <D.19541>;
    <D.19540>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1759, "ret == 0");
    <D.19541>:
  }
  D.19542 = image->assembly;
  if (D.19542 != 0B) goto <D.19543>; else goto <D.19544>;
  <D.19543>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19545>; else goto <D.19546>;
    <D.19545>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19546>:
    D.19547 = ret != 0;
    D.19548 = (long int) D.19547;
    D.19549 = __builtin_expect (D.19548, 0);
    if (D.19549 != 0) goto <D.19550>; else goto <D.19551>;
    <D.19550>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1766, "ret == 0");
    <D.19551>:
  }
  ass2 = image->assembly;
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.19481 = ass2;
  return D.19481;
  <D.19544>:
  image->assembly = ass;
  loaded_assemblies.39 = loaded_assemblies;
  loaded_assemblies.40 = monoeg_g_list_prepend (loaded_assemblies.39, ass);
  loaded_assemblies = loaded_assemblies.40;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19554>; else goto <D.19555>;
    <D.19554>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19555>:
    D.19556 = ret != 0;
    D.19557 = (long int) D.19556;
    D.19558 = __builtin_expect (D.19557, 0);
    if (D.19558 != 0) goto <D.19559>; else goto <D.19560>;
    <D.19559>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1778, "ret == 0");
    <D.19560>:
  }
  mono_assembly_invoke_load_hook (ass);
  mono_profiler_assembly_loaded (ass, 0);
  D.19481 = ass;
  return D.19481;
}


absolute_dir (const gchar * filename)
{
  int D.19562;
  gchar * D.19565;
  int D.17796;
  int iftmp.41;
  int D.17795;
  const char[2] * D.19569;
  unsigned char D.19570;
  int D.19571;
  unsigned char D.19572;
  int D.19573;
  _Bool D.19574;
  _Bool D.19575;
  _Bool D.19576;
  const unsigned char * D.19579;
  unsigned char D.19580;
  int D.19581;
  const unsigned char * D.19582;
  unsigned char D.19583;
  int D.19584;
  _Bool D.19585;
  _Bool D.19586;
  const unsigned char * D.19589;
  unsigned char D.19590;
  int D.19591;
  const unsigned char * D.19592;
  unsigned char D.19593;
  int D.19594;
  _Bool D.19595;
  _Bool D.19596;
  const unsigned char * D.19599;
  unsigned char D.19600;
  int D.19601;
  const unsigned char * D.19602;
  unsigned char D.19603;
  int D.19604;
  int D.17806;
  int iftmp.42;
  int D.17805;
  const char[3] * D.19611;
  unsigned char D.19612;
  int D.19613;
  unsigned char D.19614;
  int D.19615;
  _Bool D.19616;
  _Bool D.19617;
  _Bool D.19618;
  const unsigned char * D.19621;
  unsigned char D.19622;
  int D.19623;
  const unsigned char * D.19624;
  unsigned char D.19625;
  int D.19626;
  _Bool D.19627;
  _Bool D.19628;
  const unsigned char * D.19631;
  unsigned char D.19632;
  int D.19633;
  const unsigned char * D.19634;
  unsigned char D.19635;
  int D.19636;
  _Bool D.19637;
  _Bool D.19638;
  const unsigned char * D.19641;
  unsigned char D.19642;
  int D.19643;
  const unsigned char * D.19644;
  unsigned char D.19645;
  int D.19646;
  struct GList * D.19652;
  long unsigned int D.19656;
  long unsigned int D.19657;
  gchar * * D.19658;
  void * D.19659;
  struct GList * D.19663;
  char D.19664;
  gchar * cwd;
  gchar * mixed;
  gchar * * parts;
  gchar * part;
  struct GList * list;
  struct GList * tmp;
  struct GString * result;
  gchar * res;
  gint i;

  D.19562 = monoeg_g_path_is_absolute (filename);
  if (D.19562 != 0) goto <D.19563>; else goto <D.19564>;
  <D.19563>:
  part = monoeg_g_path_get_dirname (filename);
  res = monoeg_g_strconcat (part, "/", 0B);
  monoeg_g_free (part);
  D.19565 = res;
  return D.19565;
  <D.19564>:
  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.17808>;
  <D.17807>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.19567>; else goto <D.19568>;
    <D.19567>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = part;
      D.19569 = ".";
      D.19570 = MEM[(const unsigned char *)D.19569];
      D.19571 = (int) D.19570;
      D.19572 = *__s2;
      D.19573 = (int) D.19572;
      __result = D.19571 - D.19573;
      {
        D.19574 = __s2_len != 0;
        D.19575 = __result == 0;
        D.19576 = D.19574 & D.19575;
        if (D.19576 != 0) goto <D.19577>; else goto <D.19578>;
        <D.19577>:
        D.19579 = &MEM[(void *)"." + 1B];
        D.19580 = *D.19579;
        D.19581 = (int) D.19580;
        D.19582 = __s2 + 1;
        D.19583 = *D.19582;
        D.19584 = (int) D.19583;
        __result = D.19581 - D.19584;
        D.19585 = __s2_len > 1;
        D.19575 = __result == 0;
        D.19586 = D.19585 & D.19575;
        if (D.19586 != 0) goto <D.19587>; else goto <D.19588>;
        <D.19587>:
        D.19589 = &MEM[(void *)"." + 2B];
        D.19590 = *D.19589;
        D.19591 = (int) D.19590;
        D.19592 = __s2 + 2;
        D.19593 = *D.19592;
        D.19594 = (int) D.19593;
        __result = D.19591 - D.19594;
        D.19595 = __s2_len > 2;
        D.19575 = __result == 0;
        D.19596 = D.19595 & D.19575;
        if (D.19596 != 0) goto <D.19597>; else goto <D.19598>;
        <D.19597>:
        D.19599 = &MEM[(void *)"." + 3B];
        D.19600 = *D.19599;
        D.19601 = (int) D.19600;
        D.19602 = __s2 + 3;
        D.19603 = *D.19602;
        D.19604 = (int) D.19603;
        __result = D.19601 - D.19604;
        <D.19598>:
        <D.19588>:
        <D.19578>:
      }
      D.17795 = __result;
    }
    iftmp.41 = -D.17795;
    goto <D.19605>;
    <D.19568>:
    iftmp.41 = __builtin_strcmp (part, ".");
    <D.19605>:
    D.17796 = iftmp.41;
  }
  if (D.17796 == 0) goto <D.19606>; else goto <D.19607>;
  <D.19606>:
  // predicted unlikely by continue predictor.
  goto <D.17797>;
  <D.19607>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 2;
    if (__s2_len <= 3) goto <D.19609>; else goto <D.19610>;
    <D.19609>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = part;
      D.19611 = "..";
      D.19612 = MEM[(const unsigned char *)D.19611];
      D.19613 = (int) D.19612;
      D.19614 = *__s2;
      D.19615 = (int) D.19614;
      __result = D.19613 - D.19615;
      {
        D.19616 = __s2_len != 0;
        D.19617 = __result == 0;
        D.19618 = D.19616 & D.19617;
        if (D.19618 != 0) goto <D.19619>; else goto <D.19620>;
        <D.19619>:
        D.19621 = &MEM[(void *)".." + 1B];
        D.19622 = *D.19621;
        D.19623 = (int) D.19622;
        D.19624 = __s2 + 1;
        D.19625 = *D.19624;
        D.19626 = (int) D.19625;
        __result = D.19623 - D.19626;
        D.19627 = __s2_len > 1;
        D.19617 = __result == 0;
        D.19628 = D.19627 & D.19617;
        if (D.19628 != 0) goto <D.19629>; else goto <D.19630>;
        <D.19629>:
        D.19631 = &MEM[(void *)".." + 2B];
        D.19632 = *D.19631;
        D.19633 = (int) D.19632;
        D.19634 = __s2 + 2;
        D.19635 = *D.19634;
        D.19636 = (int) D.19635;
        __result = D.19633 - D.19636;
        D.19637 = __s2_len > 2;
        D.19617 = __result == 0;
        D.19638 = D.19637 & D.19617;
        if (D.19638 != 0) goto <D.19639>; else goto <D.19640>;
        <D.19639>:
        D.19641 = &MEM[(void *)".." + 3B];
        D.19642 = *D.19641;
        D.19643 = (int) D.19642;
        D.19644 = __s2 + 3;
        D.19645 = *D.19644;
        D.19646 = (int) D.19645;
        __result = D.19643 - D.19646;
        <D.19640>:
        <D.19630>:
        <D.19620>:
      }
      D.17805 = __result;
    }
    iftmp.42 = -D.17805;
    goto <D.19647>;
    <D.19610>:
    iftmp.42 = __builtin_strcmp (part, "..");
    <D.19647>:
    D.17806 = iftmp.42;
  }
  if (D.17806 == 0) goto <D.19648>; else goto <D.19649>;
  <D.19648>:
  if (list != 0B) goto <D.19650>; else goto <D.19651>;
  <D.19650>:
  D.19652 = list->next;
  if (D.19652 != 0B) goto <D.19653>; else goto <D.19654>;
  <D.19653>:
  list = monoeg_g_list_delete_link (list, list);
  <D.19654>:
  <D.19651>:
  goto <D.19655>;
  <D.19649>:
  list = monoeg_g_list_prepend (list, part);
  <D.19655>:
  <D.17797>:
  i = i + 1;
  <D.17808>:
  D.19656 = (long unsigned int) i;
  D.19657 = D.19656 * 8;
  D.19658 = parts + D.19657;
  part = *D.19658;
  if (part != 0B) goto <D.17807>; else goto <D.17809>;
  <D.17809>:
  result = monoeg_g_string_new ("");
  list = monoeg_g_list_reverse (list);
  tmp = list;
  goto <D.17811>;
  <D.17810>:
  D.19659 = tmp->data;
  if (D.19659 != 0B) goto <D.19660>; else goto <D.19661>;
  <D.19660>:
  D.19659 = tmp->data;
  monoeg_g_string_append_printf (result, "%s%c", D.19659, 47);
  <D.19661>:
  tmp = tmp->next;
  <D.17811>:
  if (tmp != 0B) goto <D.19662>; else goto <D.17812>;
  <D.19662>:
  D.19663 = tmp->next;
  if (D.19663 != 0B) goto <D.17810>; else goto <D.17812>;
  <D.17812>:
  res = result->str;
  monoeg_g_string_free (result, 0);
  monoeg_g_list_free (list);
  monoeg_g_strfreev (parts);
  D.19664 = *res;
  if (D.19664 == 0) goto <D.19665>; else goto <D.19666>;
  <D.19665>:
  monoeg_g_free (res);
  D.19565 = monoeg_strdup (".");
  return D.19565;
  <D.19666>:
  D.19565 = res;
  return D.19565;
}


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

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


mono_assembly_name_free (struct MonoAssemblyName * aname)
{
  const char * D.19672;
  const char * D.19673;
  const char * D.19674;

  if (aname == 0B) goto <D.19670>; else goto <D.19671>;
  <D.19670>:
  return;
  <D.19671>:
  D.19672 = aname->name;
  monoeg_g_free (D.19672);
  D.19673 = aname->culture;
  monoeg_g_free (D.19673);
  D.19674 = aname->hash_value;
  monoeg_g_free (D.19674);
}


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.19683;
  gboolean D.19684;
  gchar * D.19685;
  gchar * D.19686;
  gchar * D.19687;
  int D.19688;
  unsigned int part_name_len.43;
  long unsigned int D.19693;
  gchar * part_name.44;
  int D.19695;
  char D.19698;
  int D.19702;
  char D.19705;
  int D.19709;
  char D.19712;
  int D.19716;
  char D.19719;
  int D.19723;
  char D.19726;
  int D.19728;
  int D.19732;
  int D.19736;
  gchar * value.45;
  int D.19740;
  int D.19744;
  int D.19748;
  int D.19752;
  int D.19756;
  _Bool D.19760;
  _Bool D.19761;
  _Bool D.19762;
  _Bool D.19764;
  _Bool D.19765;
  _Bool D.19766;
  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.19676>; else goto <D.19677>;
      <D.19676>:
      is_version_defined = &version_defined;
      <D.19677>:
      *is_version_defined = 0;
      if (is_token_defined == 0B) goto <D.19678>; else goto <D.19679>;
      <D.19678>:
      is_token_defined = &token_defined;
      <D.19679>:
      *is_token_defined = 0;
      tmp = monoeg_g_strsplit (name, ",", 6);
      parts = tmp;
      if (tmp == 0B) goto <D.19680>; else goto <D.19682>;
      <D.19682>:
      D.19683 = *tmp;
      if (D.19683 == 0B) goto <D.19680>; else goto <D.19681>;
      <D.19680>:
      monoeg_g_strfreev (tmp);
      D.19684 = 0;
      return D.19684;
      <D.19681>:
      D.19683 = *tmp;
      D.19685 = monoeg_g_strchomp (D.19683);
      dllname = monoeg_g_strchug (D.19685);
      tmp = tmp + 8;
      goto <D.18032>;
      <D.18033>:
      D.19683 = *tmp;
      D.19686 = monoeg_g_strchomp (D.19683);
      D.19687 = monoeg_g_strchug (D.19686);
      D.19688 = split_key_value (D.19687, &part_name, &part_name_len, &value);
      if (D.19688 == 0) goto cleanup_and_fail; else goto <D.19689>;
      <D.19689>:
      part_name_len.43 = part_name_len;
      if (part_name_len.43 == 7) goto <D.19691>; else goto <D.19692>;
      <D.19691>:
      part_name_len.43 = part_name_len;
      D.19693 = (long unsigned int) part_name_len.43;
      part_name.44 = part_name;
      D.19695 = monoeg_g_ascii_strncasecmp (part_name.44, "Version", D.19693);
      if (D.19695 == 0) goto <D.19696>; else goto <D.19697>;
      <D.19696>:
      *is_version_defined = 1;
      version = value;
      D.19698 = MEM[(const char *)version];
      if (D.19698 == 0) goto cleanup_and_fail; else goto <D.19699>;
      <D.19699>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.18032>;
      <D.19697>:
      <D.19692>:
      part_name_len.43 = part_name_len;
      if (part_name_len.43 == 7) goto <D.19700>; else goto <D.19701>;
      <D.19700>:
      part_name_len.43 = part_name_len;
      D.19693 = (long unsigned int) part_name_len.43;
      part_name.44 = part_name;
      D.19702 = monoeg_g_ascii_strncasecmp (part_name.44, "Culture", D.19693);
      if (D.19702 == 0) goto <D.19703>; else goto <D.19704>;
      <D.19703>:
      culture = value;
      D.19705 = MEM[(const char *)culture];
      if (D.19705 == 0) goto cleanup_and_fail; else goto <D.19706>;
      <D.19706>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.18032>;
      <D.19704>:
      <D.19701>:
      part_name_len.43 = part_name_len;
      if (part_name_len.43 == 14) goto <D.19707>; else goto <D.19708>;
      <D.19707>:
      part_name_len.43 = part_name_len;
      D.19693 = (long unsigned int) part_name_len.43;
      part_name.44 = part_name;
      D.19709 = monoeg_g_ascii_strncasecmp (part_name.44, "PublicKeyToken", D.19693);
      if (D.19709 == 0) goto <D.19710>; else goto <D.19711>;
      <D.19710>:
      *is_token_defined = 1;
      token = value;
      D.19712 = MEM[(const char *)token];
      if (D.19712 == 0) goto cleanup_and_fail; else goto <D.19713>;
      <D.19713>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.18032>;
      <D.19711>:
      <D.19708>:
      part_name_len.43 = part_name_len;
      if (part_name_len.43 == 9) goto <D.19714>; else goto <D.19715>;
      <D.19714>:
      part_name_len.43 = part_name_len;
      D.19693 = (long unsigned int) part_name_len.43;
      part_name.44 = part_name;
      D.19716 = monoeg_g_ascii_strncasecmp (part_name.44, "PublicKey", D.19693);
      if (D.19716 == 0) goto <D.19717>; else goto <D.19718>;
      <D.19717>:
      key = value;
      D.19719 = MEM[(const char *)key];
      if (D.19719 == 0) goto cleanup_and_fail; else goto <D.19720>;
      <D.19720>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.18032>;
      <D.19718>:
      <D.19715>:
      part_name_len.43 = part_name_len;
      if (part_name_len.43 == 12) goto <D.19721>; else goto <D.19722>;
      <D.19721>:
      part_name_len.43 = part_name_len;
      D.19693 = (long unsigned int) part_name_len.43;
      part_name.44 = part_name;
      D.19723 = monoeg_g_ascii_strncasecmp (part_name.44, "Retargetable", D.19693);
      if (D.19723 == 0) goto <D.19724>; else goto <D.19725>;
      <D.19724>:
      retargetable = value;
      D.19726 = MEM[(const char *)retargetable];
      if (D.19726 == 0) goto cleanup_and_fail; else goto <D.19727>;
      <D.19727>:
      D.19728 = monoeg_ascii_strcasecmp (retargetable, "yes");
      if (D.19728 == 0) goto <D.19729>; else goto <D.19730>;
      <D.19729>:
      flags = flags | 256;
      goto <D.19731>;
      <D.19730>:
      D.19732 = monoeg_ascii_strcasecmp (retargetable, "no");
      if (D.19732 != 0) goto cleanup_and_fail; else goto <D.19733>;
      <D.19733>:
      <D.19731>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.18032>;
      <D.19725>:
      <D.19722>:
      part_name_len.43 = part_name_len;
      if (part_name_len.43 == 21) goto <D.19734>; else goto <D.19735>;
      <D.19734>:
      part_name_len.43 = part_name_len;
      D.19693 = (long unsigned int) part_name_len.43;
      part_name.44 = part_name;
      D.19736 = monoeg_g_ascii_strncasecmp (part_name.44, "ProcessorArchitecture", D.19693);
      if (D.19736 == 0) goto <D.19737>; else goto <D.19738>;
      <D.19737>:
      value.45 = value;
      D.19740 = monoeg_ascii_strcasecmp (value.45, "None");
      if (D.19740 == 0) goto <D.19741>; else goto <D.19742>;
      <D.19741>:
      arch = 0;
      goto <D.19743>;
      <D.19742>:
      value.45 = value;
      D.19744 = monoeg_ascii_strcasecmp (value.45, "MSIL");
      if (D.19744 == 0) goto <D.19745>; else goto <D.19746>;
      <D.19745>:
      arch = 1;
      goto <D.19747>;
      <D.19746>:
      value.45 = value;
      D.19748 = monoeg_ascii_strcasecmp (value.45, "X86");
      if (D.19748 == 0) goto <D.19749>; else goto <D.19750>;
      <D.19749>:
      arch = 2;
      goto <D.19751>;
      <D.19750>:
      value.45 = value;
      D.19752 = monoeg_ascii_strcasecmp (value.45, "IA64");
      if (D.19752 == 0) goto <D.19753>; else goto <D.19754>;
      <D.19753>:
      arch = 3;
      goto <D.19755>;
      <D.19754>:
      value.45 = value;
      D.19756 = monoeg_ascii_strcasecmp (value.45, "AMD64");
      if (D.19756 == 0) goto <D.19757>; else goto cleanup_and_fail;
      <D.19757>:
      arch = 4;
      <D.19755>:
      <D.19751>:
      <D.19747>:
      <D.19743>:
      tmp = tmp + 8;
      // predicted unlikely by continue predictor.
      goto <D.18032>;
      <D.19738>:
      <D.19735>:
      monoeg_g_strfreev (parts);
      D.19684 = 0;
      return D.19684;
      <D.18032>:
      D.19683 = *tmp;
      if (D.19683 != 0B) goto <D.18033>; else goto <D.18034>;
      <D.18034>:
      if (retargetable != 0B) goto <D.19758>; else goto <D.19759>;
      <D.19758>:
      D.19760 = version == 0B;
      D.19761 = culture == 0B;
      D.19762 = D.19760 | D.19761;
      if (D.19762 != 0) goto cleanup_and_fail; else goto <D.19763>;
      <D.19763>:
      D.19764 = key == 0B;
      D.19765 = token == 0B;
      D.19766 = D.19764 & D.19765;
      if (D.19766 != 0) goto cleanup_and_fail; else goto <D.19767>;
      <D.19767>:
      <D.19759>:
      res = build_assembly_name (dllname, version, culture, token, key, flags, arch, aname, save_public_key);
      monoeg_g_strfreev (parts);
      D.19684 = res;
      return D.19684;
      cleanup_and_fail:
      monoeg_g_strfreev (parts);
      D.19684 = 0;
      return D.19684;
    }
  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.19772;
  long int eqsign.46;
  gchar * D.19774;
  long int D.19775;
  long int D.19776;
  unsigned int D.19777;
  unsigned int D.19778;
  unsigned int D.19779;
  const short unsigned int * * D.19781;
  const short unsigned int * D.19782;
  sizetype D.19783;
  gchar * D.19784;
  char D.19785;
  long unsigned int D.19786;
  long unsigned int D.19787;
  const short unsigned int * D.19788;
  short unsigned int D.19789;
  int D.19790;
  int D.19791;
  gchar * D.19792;
  gchar * D.19793;
  gchar * D.19794;
  char * eqsign;

  eqsign = __builtin_strchr (pair, 61);
  if (eqsign == 0B) goto <D.19770>; else goto <D.19771>;
  <D.19770>:
  *key = 0B;
  *keylen = 0;
  *value = 0B;
  D.19772 = 0;
  return D.19772;
  <D.19771>:
  *key = pair;
  eqsign.46 = (long int) eqsign;
  D.19774 = *key;
  D.19775 = (long int) D.19774;
  D.19776 = eqsign.46 - D.19775;
  D.19777 = (unsigned int) D.19776;
  *keylen = D.19777;
  goto <D.18006>;
  <D.18005>:
  D.19778 = *keylen;
  D.19779 = D.19778 + 4294967295;
  *keylen = D.19779;
  <D.18006>:
  D.19778 = *keylen;
  if (D.19778 != 0) goto <D.19780>; else goto <D.18007>;
  <D.19780>:
  D.19781 = __ctype_b_loc ();
  D.19782 = *D.19781;
  D.19774 = *key;
  D.19778 = *keylen;
  D.19779 = D.19778 + 4294967295;
  D.19783 = (sizetype) D.19779;
  D.19784 = D.19774 + D.19783;
  D.19785 = *D.19784;
  D.19786 = (long unsigned int) D.19785;
  D.19787 = D.19786 * 2;
  D.19788 = D.19782 + D.19787;
  D.19789 = *D.19788;
  D.19790 = (int) D.19789;
  D.19791 = D.19790 & 8192;
  if (D.19791 != 0) goto <D.18005>; else goto <D.18007>;
  <D.18007>:
  D.19792 = eqsign + 1;
  D.19793 = monoeg_g_strchomp (D.19792);
  D.19794 = monoeg_g_strchug (D.19793);
  *value = D.19794;
  D.19772 = 1;
  return D.19772;
}


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.47;
  unsigned int D.19799;
  gboolean D.19802;
  int major.48;
  short unsigned int D.19804;
  int minor.49;
  short unsigned int D.19806;
  int build.50;
  short unsigned int D.19810;
  int revision.51;
  short unsigned int D.19815;
  short unsigned int D.19817;
  gchar * D.19818;
  int D.19821;
  gchar * D.19824;
  gchar * D.19826;
  int D.19829;
  long unsigned int D.19832;
  mono_byte[17] * D.19835;
  int D.17990;
  int iftmp.52;
  int D.17989;
  const char[5] * D.19843;
  unsigned char D.19844;
  int D.19845;
  unsigned char D.19846;
  int D.19847;
  _Bool D.19848;
  _Bool D.19849;
  _Bool D.19850;
  const unsigned char * D.19853;
  unsigned char D.19854;
  int D.19855;
  const unsigned char * D.19856;
  unsigned char D.19857;
  int D.19858;
  _Bool D.19859;
  _Bool D.19860;
  const unsigned char * D.19863;
  unsigned char D.19864;
  int D.19865;
  const unsigned char * D.19866;
  unsigned char D.19867;
  int D.19868;
  _Bool D.19869;
  _Bool D.19870;
  const unsigned char * D.19873;
  unsigned char D.19874;
  int D.19875;
  const unsigned char * D.19876;
  unsigned char D.19877;
  int D.19878;
  int D.19881;
  int is_ecma.53;
  gchar * pkey.54;
  unsigned int D.19889;
  unsigned int len.55;
  gchar * pkeyptr.56;
  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.19796>; else goto <D.19797>;
      <D.19796>:
      version_parts = sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision);
      version_parts.47 = (unsigned int) version_parts;
      D.19799 = version_parts.47 + 4294967294;
      if (D.19799 > 2) goto <D.19800>; else goto <D.19801>;
      <D.19800>:
      D.19802 = 0;
      return D.19802;
      <D.19801>:
      major.48 = major;
      D.19804 = (short unsigned int) major.48;
      aname->major = D.19804;
      minor.49 = minor;
      D.19806 = (short unsigned int) minor.49;
      aname->minor = D.19806;
      if (version_parts > 2) goto <D.19807>; else goto <D.19808>;
      <D.19807>:
      build.50 = build;
      D.19810 = (short unsigned int) build.50;
      aname->build = D.19810;
      goto <D.19811>;
      <D.19808>:
      aname->build = 0;
      <D.19811>:
      if (version_parts == 4) goto <D.19812>; else goto <D.19813>;
      <D.19812>:
      revision.51 = revision;
      D.19815 = (short unsigned int) revision.51;
      aname->revision = D.19815;
      goto <D.19816>;
      <D.19813>:
      aname->revision = 0;
      <D.19816>:
      <D.19797>:
      aname->flags = flags;
      D.19817 = (short unsigned int) arch;
      aname->arch = D.19817;
      D.19818 = monoeg_strdup (name);
      aname->name = D.19818;
      if (culture != 0B) goto <D.19819>; else goto <D.19820>;
      <D.19819>:
      D.19821 = monoeg_ascii_strcasecmp (culture, "neutral");
      if (D.19821 == 0) goto <D.19822>; else goto <D.19823>;
      <D.19822>:
      D.19824 = monoeg_strdup ("");
      aname->culture = D.19824;
      goto <D.19825>;
      <D.19823>:
      D.19826 = monoeg_strdup (culture);
      aname->culture = D.19826;
      <D.19825>:
      <D.19820>:
      if (token != 0B) goto <D.19827>; else goto <D.19828>;
      <D.19827>:
      D.19829 = strncmp (token, "null", 4);
      if (D.19829 != 0) goto <D.19830>; else goto <D.19831>;
      <D.19830>:
      {
        char * lower;

        D.19832 = strlen (token);
        if (D.19832 != 16) goto <D.19833>; else goto <D.19834>;
        <D.19833>:
        mono_assembly_name_free (aname);
        D.19802 = 0;
        return D.19802;
        <D.19834>:
        lower = monoeg_g_ascii_strdown (token, 17);
        D.19835 = &aname->public_key_token;
        monoeg_g_strlcpy (D.19835, lower, 17);
        monoeg_g_free (lower);
      }
      <D.19831>:
      <D.19828>:
      if (key != 0B) goto <D.19836>; else goto <D.19837>;
      <D.19836>:
      {
        gboolean is_ecma;

        try
          {
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 4;
              if (__s2_len <= 3) goto <D.19841>; else goto <D.19842>;
              <D.19841>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = key;
                D.19843 = "null";
                D.19844 = MEM[(const unsigned char *)D.19843];
                D.19845 = (int) D.19844;
                D.19846 = *__s2;
                D.19847 = (int) D.19846;
                __result = D.19845 - D.19847;
                {
                  D.19848 = __s2_len != 0;
                  D.19849 = __result == 0;
                  D.19850 = D.19848 & D.19849;
                  if (D.19850 != 0) goto <D.19851>; else goto <D.19852>;
                  <D.19851>:
                  D.19853 = &MEM[(void *)"null" + 1B];
                  D.19854 = *D.19853;
                  D.19855 = (int) D.19854;
                  D.19856 = __s2 + 1;
                  D.19857 = *D.19856;
                  D.19858 = (int) D.19857;
                  __result = D.19855 - D.19858;
                  D.19859 = __s2_len > 1;
                  D.19849 = __result == 0;
                  D.19860 = D.19859 & D.19849;
                  if (D.19860 != 0) goto <D.19861>; else goto <D.19862>;
                  <D.19861>:
                  D.19863 = &MEM[(void *)"null" + 2B];
                  D.19864 = *D.19863;
                  D.19865 = (int) D.19864;
                  D.19866 = __s2 + 2;
                  D.19867 = *D.19866;
                  D.19868 = (int) D.19867;
                  __result = D.19865 - D.19868;
                  D.19869 = __s2_len > 2;
                  D.19849 = __result == 0;
                  D.19870 = D.19869 & D.19849;
                  if (D.19870 != 0) goto <D.19871>; else goto <D.19872>;
                  <D.19871>:
                  D.19873 = &MEM[(void *)"null" + 3B];
                  D.19874 = *D.19873;
                  D.19875 = (int) D.19874;
                  D.19876 = __s2 + 3;
                  D.19877 = *D.19876;
                  D.19878 = (int) D.19877;
                  __result = D.19875 - D.19878;
                  <D.19872>:
                  <D.19862>:
                  <D.19852>:
                }
                D.17989 = __result;
              }
              iftmp.52 = -D.17989;
              goto <D.19879>;
              <D.19842>:
              iftmp.52 = __builtin_strcmp (key, "null");
              <D.19879>:
              D.17990 = iftmp.52;
            }
            if (D.17990 == 0) goto <D.19838>; else goto <D.19880>;
            <D.19880>:
            D.19881 = parse_public_key (key, &pkey, &is_ecma);
            if (D.19881 == 0) goto <D.19838>; else goto <D.19839>;
            <D.19838>:
            mono_assembly_name_free (aname);
            D.19802 = 0;
            return D.19802;
            <D.19839>:
            is_ecma.53 = is_ecma;
            if (is_ecma.53 != 0) goto <D.19883>; else goto <D.19884>;
            <D.19883>:
            if (save_public_key != 0) goto <D.19885>; else goto <D.19886>;
            <D.19885>:
            pkey.54 = pkey;
            aname->public_key = pkey.54;
            goto <D.19888>;
            <D.19886>:
            pkey.54 = pkey;
            monoeg_g_free (pkey.54);
            <D.19888>:
            D.19835 = &aname->public_key_token;
            monoeg_g_strlcpy (D.19835, "b77a5c561934e089", 17);
            D.19802 = 1;
            return D.19802;
            <D.19884>:
            pkey.54 = pkey;
            D.19889 = mono_metadata_decode_blob_size (pkey.54, &pkeyptr);
            len = (gint) D.19889;
            len.55 = (unsigned int) len;
            pkeyptr.56 = pkeyptr;
            mono_digest_get_public_token (&tok, pkeyptr.56, len.55);
            encoded = encode_public_tok (&tok, 8);
            D.19835 = &aname->public_key_token;
            monoeg_g_strlcpy (D.19835, encoded, 17);
            monoeg_g_free (encoded);
            if (save_public_key != 0) goto <D.19892>; else goto <D.19893>;
            <D.19892>:
            pkey.54 = pkey;
            aname->public_key = pkey.54;
            goto <D.19894>;
            <D.19893>:
            pkey.54 = pkey;
            monoeg_g_free (pkey.54);
            <D.19894>:
          }
        finally
          {
            is_ecma = {CLOBBER};
          }
      }
      <D.19837>:
      D.19802 = 1;
      return D.19802;
    }
  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.19899;
  long unsigned int D.19900;
  gboolean D.19903;
  int D.17939;
  int iftmp.57;
  int D.17938;
  const char[33] * D.19907;
  unsigned char D.19908;
  int D.19909;
  unsigned char D.19910;
  int D.19911;
  _Bool D.19912;
  _Bool D.19913;
  _Bool D.19914;
  const unsigned char * D.19917;
  unsigned char D.19918;
  int D.19919;
  const unsigned char * D.19920;
  unsigned char D.19921;
  int D.19922;
  _Bool D.19923;
  _Bool D.19924;
  const unsigned char * D.19927;
  unsigned char D.19928;
  int D.19929;
  const unsigned char * D.19930;
  unsigned char D.19931;
  int D.19932;
  _Bool D.19933;
  _Bool D.19934;
  const unsigned char * D.19937;
  unsigned char D.19938;
  int D.19939;
  const unsigned char * D.19940;
  unsigned char D.19941;
  int D.19942;
  gchar * D.19948;
  char D.19949;
  int D.19950;
  int D.19951;
  int D.19952;
  const gchar * D.19953;
  char D.19954;
  int D.19955;
  int D.19956;
  char D.19957;
  int D.19958;
  const gchar * D.19961;
  char D.19962;
  int D.19963;
  int D.19964;
  const gchar * D.19965;
  char D.19966;
  int D.19967;
  int D.19968;
  char D.19969;
  long unsigned int D.19972;
  long unsigned int D.19973;
  int j.58;
  sizetype D.19977;
  const gchar * D.19978;
  char D.19979;
  int D.19980;
  int D.19981;
  int D.19982;
  char D.19983;
  int j.59;
  sizetype D.19985;
  const gchar * D.19986;
  char D.19987;
  int D.19988;
  int D.19989;
  char D.19990;
  char D.19991;
  char D.19992;
  char D.19995;
  char D.19997;
  char D.19999;
  char D.20001;
  const guint32 * D.20003;
  unsigned int D.20004;
  const guint32 * D.20005;
  unsigned int D.20006;
  unsigned int D.20007;
  int D.20008;
  int D.20015;
  long unsigned int D.20016;
  int offset.60;
  sizetype D.20018;
  gchar * D.20019;
  char D.20020;
  int D.20022;
  long unsigned int D.20023;
  int offset.61;
  sizetype D.20025;
  gchar * D.20026;
  int offset.62;
  sizetype D.20028;
  gchar * D.20029;
  sizetype D.20030;
  gchar * D.20031;
  int j.63;
  sizetype D.20033;
  const gchar * D.20034;
  char D.20035;
  int D.20036;
  int D.20037;
  int D.20038;
  char D.20039;
  int j.64;
  sizetype D.20041;
  const gchar * D.20042;
  char D.20043;
  int D.20044;
  int D.20045;
  char D.20046;
  char D.20047;
  char D.20048;
  int D.20049;
  const gchar * pkey;
  gchar header[16];
  gchar val;
  gchar * arr;
  gint i;
  gint j;
  gint offset;
  gint bitlen;
  gint keylen;
  gint pkeylen;

  try
    {
      D.19899 = strlen (key);
      D.19900 = D.19899 >> 1;
      keylen = (gint) D.19900;
      if (keylen <= 0) goto <D.19901>; else goto <D.19902>;
      <D.19901>:
      D.19903 = 0;
      return D.19903;
      <D.19902>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 32;
        if (__s2_len <= 3) goto <D.19905>; else goto <D.19906>;
        <D.19905>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = key;
          D.19907 = "00000000000000000400000000000000";
          D.19908 = MEM[(const unsigned char *)D.19907];
          D.19909 = (int) D.19908;
          D.19910 = *__s2;
          D.19911 = (int) D.19910;
          __result = D.19909 - D.19911;
          {
            D.19912 = __s2_len != 0;
            D.19913 = __result == 0;
            D.19914 = D.19912 & D.19913;
            if (D.19914 != 0) goto <D.19915>; else goto <D.19916>;
            <D.19915>:
            D.19917 = &MEM[(void *)"00000000000000000400000000000000" + 1B];
            D.19918 = *D.19917;
            D.19919 = (int) D.19918;
            D.19920 = __s2 + 1;
            D.19921 = *D.19920;
            D.19922 = (int) D.19921;
            __result = D.19919 - D.19922;
            D.19923 = __s2_len > 1;
            D.19913 = __result == 0;
            D.19924 = D.19923 & D.19913;
            if (D.19924 != 0) goto <D.19925>; else goto <D.19926>;
            <D.19925>:
            D.19927 = &MEM[(void *)"00000000000000000400000000000000" + 2B];
            D.19928 = *D.19927;
            D.19929 = (int) D.19928;
            D.19930 = __s2 + 2;
            D.19931 = *D.19930;
            D.19932 = (int) D.19931;
            __result = D.19929 - D.19932;
            D.19933 = __s2_len > 2;
            D.19913 = __result == 0;
            D.19934 = D.19933 & D.19913;
            if (D.19934 != 0) goto <D.19935>; else goto <D.19936>;
            <D.19935>:
            D.19937 = &MEM[(void *)"00000000000000000400000000000000" + 3B];
            D.19938 = *D.19937;
            D.19939 = (int) D.19938;
            D.19940 = __s2 + 3;
            D.19941 = *D.19940;
            D.19942 = (int) D.19941;
            __result = D.19939 - D.19942;
            <D.19936>:
            <D.19926>:
            <D.19916>:
          }
          D.17938 = __result;
        }
        iftmp.57 = -D.17938;
        goto <D.19943>;
        <D.19906>:
        iftmp.57 = __builtin_strcmp (key, "00000000000000000400000000000000");
        <D.19943>:
        D.17939 = iftmp.57;
      }
      if (D.17939 == 0) goto <D.19944>; else goto <D.19945>;
      <D.19944>:
      if (pubkey != 0B) goto <D.19946>; else goto <D.19947>;
      <D.19946>:
      D.19948 = monoeg_strdup (key);
      *pubkey = D.19948;
      *is_ecma = 1;
      <D.19947>:
      D.19903 = 1;
      return D.19903;
      <D.19945>:
      *is_ecma = 0;
      D.19949 = *key;
      D.19950 = (int) D.19949;
      D.19951 = monoeg_g_ascii_xdigit_value (D.19950);
      D.19952 = D.19951 << 4;
      val = (gchar) D.19952;
      D.19953 = key + 1;
      D.19954 = *D.19953;
      D.19955 = (int) D.19954;
      D.19956 = monoeg_g_ascii_xdigit_value (D.19955);
      D.19957 = (char) D.19956;
      val = D.19957 | val;
      D.19958 = (int) val;
      switch (D.19958) <default: <D.17943>, case 0: <D.17940>, case 6: <D.17942>>
      <D.17940>:
      if (keylen <= 12) goto <D.19959>; else goto <D.19960>;
      <D.19959>:
      D.19903 = 0;
      return D.19903;
      <D.19960>:
      D.19961 = key + 24;
      D.19962 = *D.19961;
      D.19963 = (int) D.19962;
      D.19964 = monoeg_g_ascii_xdigit_value (D.19963);
      val = (gchar) D.19964;
      D.19965 = key + 25;
      D.19966 = *D.19965;
      D.19967 = (int) D.19966;
      D.19968 = monoeg_g_ascii_xdigit_value (D.19967);
      D.19969 = (char) D.19968;
      val = D.19969 | val;
      if (val != 6) goto <D.19970>; else goto <D.19971>;
      <D.19970>:
      D.19903 = 0;
      return D.19903;
      <D.19971>:
      pkey = key + 24;
      goto <D.17941>;
      <D.17942>:
      pkey = key;
      goto <D.17941>;
      <D.17943>:
      D.19903 = 0;
      return D.19903;
      <D.17941>:
      D.19972 = strlen (pkey);
      D.19973 = D.19972 >> 1;
      pkeylen = (gint) D.19973;
      if (pkeylen <= 15) goto <D.19974>; else goto <D.19975>;
      <D.19974>:
      D.19903 = 0;
      return D.19903;
      <D.19975>:
      i = 0;
      j = 0;
      goto <D.17945>;
      <D.17944>:
      j.58 = j;
      j = j.58 + 1;
      D.19977 = (sizetype) j.58;
      D.19978 = pkey + D.19977;
      D.19979 = *D.19978;
      D.19980 = (int) D.19979;
      D.19981 = monoeg_g_ascii_xdigit_value (D.19980);
      D.19982 = D.19981 << 4;
      D.19983 = (char) D.19982;
      header[i] = D.19983;
      j.59 = j;
      j = j.59 + 1;
      D.19985 = (sizetype) j.59;
      D.19986 = pkey + D.19985;
      D.19987 = *D.19986;
      D.19988 = (int) D.19987;
      D.19989 = monoeg_g_ascii_xdigit_value (D.19988);
      D.19990 = header[i];
      D.19991 = (char) D.19989;
      D.19992 = D.19990 | D.19991;
      header[i] = D.19992;
      i = i + 1;
      <D.17945>:
      if (i <= 15) goto <D.17944>; else goto <D.17946>;
      <D.17946>:
      D.19995 = header[0];
      if (D.19995 != 6) goto <D.19993>; else goto <D.19996>;
      <D.19996>:
      D.19997 = header[1];
      if (D.19997 != 2) goto <D.19993>; else goto <D.19998>;
      <D.19998>:
      D.19999 = header[2];
      if (D.19999 != 0) goto <D.19993>; else goto <D.20000>;
      <D.20000>:
      D.20001 = header[3];
      if (D.20001 != 0) goto <D.19993>; else goto <D.20002>;
      <D.20002>:
      D.20003 = &MEM[(void *)&header + 8B];
      D.20004 = *D.20003;
      if (D.20004 != 826364754) goto <D.19993>; else goto <D.19994>;
      <D.19993>:
      D.19903 = 0;
      return D.19903;
      <D.19994>:
      D.20005 = &MEM[(void *)&header + 12B];
      D.20006 = *D.20005;
      D.20007 = D.20006 >> 3;
      bitlen = (gint) D.20007;
      D.20008 = bitlen + 20;
      if (D.20008 != pkeylen) goto <D.20009>; else goto <D.20010>;
      <D.20009>:
      D.19903 = 0;
      return D.19903;
      <D.20010>:
      if (pubkey == 0B) goto <D.20011>; else goto <D.20012>;
      <D.20011>:
      D.19903 = 1;
      return D.19903;
      <D.20012>:
      offset = 0;
      if (keylen <= 127) goto <D.20013>; else goto <D.20014>;
      <D.20013>:
      D.20015 = keylen + 1;
      D.20016 = (long unsigned int) D.20015;
      arr = monoeg_malloc (D.20016);
      offset.60 = offset;
      offset = offset.60 + 1;
      D.20018 = (sizetype) offset.60;
      D.20019 = arr + D.20018;
      D.20020 = (char) keylen;
      *D.20019 = D.20020;
      goto <D.20021>;
      <D.20014>:
      D.20022 = keylen + 2;
      D.20023 = (long unsigned int) D.20022;
      arr = monoeg_malloc (D.20023);
      offset.61 = offset;
      offset = offset.61 + 1;
      D.20025 = (sizetype) offset.61;
      D.20026 = arr + D.20025;
      *D.20026 = -128;
      offset.62 = offset;
      offset = offset.62 + 1;
      D.20028 = (sizetype) offset.62;
      D.20029 = arr + D.20028;
      D.20020 = (char) keylen;
      *D.20029 = D.20020;
      <D.20021>:
      i = offset;
      j = 0;
      goto <D.17948>;
      <D.17947>:
      D.20030 = (sizetype) i;
      D.20031 = arr + D.20030;
      j.63 = j;
      j = j.63 + 1;
      D.20033 = (sizetype) j.63;
      D.20034 = key + D.20033;
      D.20035 = *D.20034;
      D.20036 = (int) D.20035;
      D.20037 = monoeg_g_ascii_xdigit_value (D.20036);
      D.20038 = D.20037 << 4;
      D.20039 = (char) D.20038;
      *D.20031 = D.20039;
      j.64 = j;
      j = j.64 + 1;
      D.20041 = (sizetype) j.64;
      D.20042 = key + D.20041;
      D.20043 = *D.20042;
      D.20044 = (int) D.20043;
      D.20045 = monoeg_g_ascii_xdigit_value (D.20044);
      D.20030 = (sizetype) i;
      D.20031 = arr + D.20030;
      D.20030 = (sizetype) i;
      D.20031 = arr + D.20030;
      D.20046 = *D.20031;
      D.20047 = (char) D.20045;
      D.20048 = D.20046 | D.20047;
      *D.20031 = D.20048;
      i = i + 1;
      <D.17948>:
      D.20049 = keylen + offset;
      if (D.20049 > i) goto <D.17947>; else goto <D.17949>;
      <D.17949>:
      *pubkey = arr;
      D.19903 = 1;
      return D.19903;
    }
  finally
    {
      header = {CLOBBER};
    }
}


mono_assembly_name_parse (const char * name, struct MonoAssemblyName * aname)
{
  gboolean D.20052;

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


mono_assembly_name_new (const char * name)
{
  int D.20054;
  struct MonoAssemblyName * D.20057;
  struct MonoAssemblyName * aname;

  aname = monoeg_malloc0 (80);
  D.20054 = mono_assembly_name_parse (name, aname);
  if (D.20054 != 0) goto <D.20055>; else goto <D.20056>;
  <D.20055>:
  D.20057 = aname;
  return D.20057;
  <D.20056>:
  monoeg_g_free (aname);
  D.20057 = 0B;
  return D.20057;
}


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

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


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

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


mono_assembly_name_get_pubkeytoken (struct MonoAssemblyName * aname)
{
  unsigned char D.20063;
  mono_byte * D.20066;

  D.20063 = aname->public_key_token[0];
  if (D.20063 != 0) goto <D.20064>; else goto <D.20065>;
  <D.20064>:
  D.20066 = &aname->public_key_token;
  return D.20066;
  <D.20065>:
  D.20066 = 0B;
  return D.20066;
}


mono_assembly_name_get_version (struct MonoAssemblyName * aname, uint16_t * minor, uint16_t * build, uint16_t * revision)
{
  short unsigned int D.20070;
  short unsigned int D.20073;
  short unsigned int D.20076;
  uint16_t D.20077;

  if (minor != 0B) goto <D.20068>; else goto <D.20069>;
  <D.20068>:
  D.20070 = aname->minor;
  *minor = D.20070;
  <D.20069>:
  if (build != 0B) goto <D.20071>; else goto <D.20072>;
  <D.20071>:
  D.20073 = aname->build;
  *build = D.20073;
  <D.20072>:
  if (revision != 0B) goto <D.20074>; else goto <D.20075>;
  <D.20074>:
  D.20076 = aname->revision;
  *revision = D.20076;
  <D.20075>:
  D.20077 = aname->major;
  return D.20077;
}


mono_assembly_load_with_partial_name (const char * name, MonoImageOpenStatus * status)
{
  int D.20079;
  struct MonoAssembly * D.20082;
  short unsigned int D.20083;
  short unsigned int D.20084;
  short unsigned int D.20085;
  short unsigned int D.20086;
  short unsigned int D.20087;
  short unsigned int D.20088;
  short unsigned int D.20089;
  char * * assemblies_path.65;
  const char * D.20097;
  char * * extra_gac_paths.66;
  gchar * D.20101;
  const char * D.20105;
  struct MonoString * D.20109;
  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.20079 = mono_assembly_name_parse (name, aname);
      if (D.20079 == 0) goto <D.20080>; else goto <D.20081>;
      <D.20080>:
      D.20082 = 0B;
      return D.20082;
      <D.20081>:
      D.20083 = aname->major;
      D.20084 = aname->minor;
      D.20085 = D.20083 | D.20084;
      D.20086 = aname->build;
      D.20087 = D.20085 | D.20086;
      D.20088 = aname->revision;
      D.20089 = D.20087 | D.20088;
      if (D.20089 == 0) goto <D.20090>; else goto <D.20091>;
      <D.20090>:
      aname = mono_assembly_remap_version (aname, &mapped_aname);
      <D.20091>:
      res = mono_assembly_loaded (aname);
      if (res != 0B) goto <D.20092>; else goto <D.20093>;
      <D.20092>:
      mono_assembly_name_free (aname);
      D.20082 = res;
      return D.20082;
      <D.20093>:
      assemblies_path.65 = assemblies_path;
      res = invoke_assembly_preload_hook (aname, assemblies_path.65);
      if (res != 0B) goto <D.20095>; else goto <D.20096>;
      <D.20095>:
      res->in_gac = 0;
      mono_assembly_name_free (aname);
      D.20082 = res;
      return D.20082;
      <D.20096>:
      D.20097 = aname->name;
      fullname = monoeg_g_strdup_printf ("%s.dll", D.20097);
      extra_gac_paths.66 = extra_gac_paths;
      if (extra_gac_paths.66 != 0B) goto <D.20099>; else goto <D.20100>;
      <D.20099>:
      paths = extra_gac_paths;
      goto <D.18099>;
      <D.18098>:
      D.20097 = aname->name;
      D.20101 = *paths;
      gacpath = monoeg_g_build_path ("/", D.20101, "lib", "mono", "gac", D.20097, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      paths = paths + 8;
      <D.18099>:
      if (res == 0B) goto <D.20102>; else goto <D.18100>;
      <D.20102>:
      D.20101 = *paths;
      if (D.20101 != 0B) goto <D.18098>; else goto <D.18100>;
      <D.18100>:
      <D.20100>:
      if (res != 0B) goto <D.20103>; else goto <D.20104>;
      <D.20103>:
      res->in_gac = 1;
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.20082 = res;
      return D.20082;
      <D.20104>:
      D.20097 = aname->name;
      D.20105 = mono_assembly_getrootdir ();
      gacpath = monoeg_g_build_path ("/", D.20105, "mono", "gac", D.20097, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      if (res != 0B) goto <D.20106>; else goto <D.20107>;
      <D.20106>:
      res->in_gac = 1;
      goto <D.20108>;
      <D.20107>:
      {
        struct MonoDomain * domain;
        struct MonoReflectionAssembly * refasm;

        domain = mono_domain_get ();
        D.20109 = mono_string_new (domain, name);
        refasm = mono_try_assembly_resolve (domain, D.20109, 0);
        if (refasm != 0B) goto <D.20110>; else goto <D.20111>;
        <D.20110>:
        res = refasm->assembly;
        <D.20111>:
      }
      <D.20108>:
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.20082 = res;
      return D.20082;
    }
  finally
    {
      base_name = {CLOBBER};
      mapped_aname = {CLOBBER};
    }
}


mono_assembly_remap_version (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_aname)
{
  const char * D.20114;
  struct MonoAssemblyName * D.20117;
  unsigned int D.20118;
  unsigned int D.20119;
  short unsigned int D.20122;
  short unsigned int D.20123;
  short unsigned int D.20124;
  short unsigned int D.20125;
  unsigned int D.20126;
  unsigned int D.20127;
  int D.17601;
  int iftmp.67;
  int D.17600;
  const char[11] * D.20131;
  unsigned char D.20132;
  int D.20133;
  unsigned char D.20134;
  int D.20135;
  _Bool D.20136;
  _Bool D.20137;
  _Bool D.20138;
  const unsigned char * D.20141;
  unsigned char D.20142;
  int D.20143;
  const unsigned char * D.20144;
  unsigned char D.20145;
  int D.20146;
  _Bool D.20147;
  _Bool D.20148;
  const unsigned char * D.20151;
  unsigned char D.20152;
  int D.20153;
  const unsigned char * D.20154;
  unsigned char D.20155;
  int D.20156;
  _Bool D.20157;
  _Bool D.20158;
  const unsigned char * D.20161;
  unsigned char D.20162;
  int D.20163;
  const unsigned char * D.20164;
  unsigned char D.20165;
  int D.20166;
  gchar * D.20170;
  int D.20171;
  int D.20172;
  int D.20173;
  int D.20174;
  const char * D.20175;
  short unsigned int D.20176;
  int D.20177;
  short unsigned int D.20178;
  int D.20179;
  short unsigned int D.20180;
  int D.20181;
  short unsigned int D.20182;
  int D.20183;
  int D.20184;
  int D.20185;
  int res.68;
  const char * D.20186;
  unsigned char D.20189;
  unsigned int index.69;
  _Bool D.20191;
  long int D.20192;
  long int D.20193;
  short unsigned int D.20196;
  short unsigned int D.20199;
  short unsigned int D.20202;
  short unsigned int D.20205;
  short unsigned int D.20208;
  short unsigned int D.20209;
  short unsigned int D.20210;
  int D.20213;
  int D.20214;
  int D.20215;
  int D.20216;
  const struct MonoRuntimeInfo * current_runtime;
  int pos;
  int first;
  int last;

  D.20114 = aname->name;
  if (D.20114 == 0B) goto <D.20115>; else goto <D.20116>;
  <D.20115>:
  D.20117 = aname;
  return D.20117;
  <D.20116>:
  current_runtime = mono_get_runtime_info ();
  D.20118 = aname->flags;
  D.20119 = D.20118 & 256;
  if (D.20119 != 0) goto <D.20120>; else goto <D.20121>;
  <D.20120>:
  {
    const struct AssemblyVersionSet * vset;

    vset = &current_runtime->version_sets[0];
    memcpy (dest_aname, aname, 80);
    D.20122 = vset->major;
    dest_aname->major = D.20122;
    D.20123 = vset->minor;
    dest_aname->minor = D.20123;
    D.20124 = vset->build;
    dest_aname->build = D.20124;
    D.20125 = vset->revision;
    dest_aname->revision = D.20125;
    D.20126 = dest_aname->flags;
    D.20127 = D.20126 & 4294967039;
    dest_aname->flags = D.20127;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 10;
      if (__s2_len <= 3) goto <D.20129>; else goto <D.20130>;
      <D.20129>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = aname->name;
        D.20131 = "System.Net";
        D.20132 = MEM[(const unsigned char *)D.20131];
        D.20133 = (int) D.20132;
        D.20134 = *__s2;
        D.20135 = (int) D.20134;
        __result = D.20133 - D.20135;
        {
          D.20136 = __s2_len != 0;
          D.20137 = __result == 0;
          D.20138 = D.20136 & D.20137;
          if (D.20138 != 0) goto <D.20139>; else goto <D.20140>;
          <D.20139>:
          D.20141 = &MEM[(void *)"System.Net" + 1B];
          D.20142 = *D.20141;
          D.20143 = (int) D.20142;
          D.20144 = __s2 + 1;
          D.20145 = *D.20144;
          D.20146 = (int) D.20145;
          __result = D.20143 - D.20146;
          D.20147 = __s2_len > 1;
          D.20137 = __result == 0;
          D.20148 = D.20147 & D.20137;
          if (D.20148 != 0) goto <D.20149>; else goto <D.20150>;
          <D.20149>:
          D.20151 = &MEM[(void *)"System.Net" + 2B];
          D.20152 = *D.20151;
          D.20153 = (int) D.20152;
          D.20154 = __s2 + 2;
          D.20155 = *D.20154;
          D.20156 = (int) D.20155;
          __result = D.20153 - D.20156;
          D.20157 = __s2_len > 2;
          D.20137 = __result == 0;
          D.20158 = D.20157 & D.20137;
          if (D.20158 != 0) goto <D.20159>; else goto <D.20160>;
          <D.20159>:
          D.20161 = &MEM[(void *)"System.Net" + 3B];
          D.20162 = *D.20161;
          D.20163 = (int) D.20162;
          D.20164 = __s2 + 3;
          D.20165 = *D.20164;
          D.20166 = (int) D.20165;
          __result = D.20163 - D.20166;
          <D.20160>:
          <D.20150>:
          <D.20140>:
        }
        D.17600 = __result;
      }
      iftmp.67 = -D.17600;
      goto <D.20167>;
      <D.20130>:
      D.20114 = aname->name;
      iftmp.67 = __builtin_strcmp (D.20114, "System.Net");
      <D.20167>:
      D.17601 = iftmp.67;
    }
    if (D.17601 == 0) goto <D.20168>; else goto <D.20169>;
    <D.20168>:
    D.20170 = monoeg_strdup ("System");
    dest_aname->name = D.20170;
    <D.20169>:
    remap_keys (dest_aname);
    D.20125 = vset->revision;
    D.20171 = (int) D.20125;
    D.20124 = vset->build;
    D.20172 = (int) D.20124;
    D.20123 = vset->minor;
    D.20173 = (int) D.20123;
    D.20122 = vset->major;
    D.20174 = (int) D.20122;
    D.20175 = dest_aname->name;
    D.20176 = aname->revision;
    D.20177 = (int) D.20176;
    D.20178 = aname->build;
    D.20179 = (int) D.20178;
    D.20180 = aname->minor;
    D.20181 = (int) D.20180;
    D.20182 = aname->major;
    D.20183 = (int) D.20182;
    D.20114 = aname->name;
    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.20114, D.20183, D.20181, D.20179, D.20177, D.20175, D.20174, D.20173, D.20172, D.20171);
    D.20117 = dest_aname;
    return D.20117;
  }
  <D.20121>:
  first = 0;
  last = 62;
  goto <D.17615>;
  <D.17614>:
  {
    int res;

    D.20184 = last - first;
    D.20185 = D.20184 / 2;
    pos = D.20185 + first;
    {
      size_t __s1_len;
      size_t __s2_len;

      D.20186 = framework_assemblies[pos].assembly_name;
      D.20114 = aname->name;
      res.68 = __builtin_strcmp (D.20114, D.20186);
    }
    res = res.68;
    if (res == 0) goto <D.20187>; else goto <D.20188>;
    <D.20187>:
    {
      const struct AssemblyVersionSet * vset;
      int index;

      D.20189 = framework_assemblies[pos].version_set_index;
      index = (int) D.20189;
      index.69 = (unsigned int) index;
      D.20191 = index.69 > 3;
      D.20192 = (long int) D.20191;
      D.20193 = __builtin_expect (D.20192, 0);
      if (D.20193 != 0) goto <D.20194>; else goto <D.20195>;
      <D.20194>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 995, "index < G_N_ELEMENTS (current_runtime->version_sets)");
      <D.20195>:
      vset = &current_runtime->version_sets[index];
      D.20182 = aname->major;
      D.20196 = vset->major;
      if (D.20182 == D.20196) goto <D.20197>; else goto <D.20198>;
      <D.20197>:
      D.20180 = aname->minor;
      D.20199 = vset->minor;
      if (D.20180 == D.20199) goto <D.20200>; else goto <D.20201>;
      <D.20200>:
      D.20178 = aname->build;
      D.20202 = vset->build;
      if (D.20178 == D.20202) goto <D.20203>; else goto <D.20204>;
      <D.20203>:
      D.20176 = aname->revision;
      D.20205 = vset->revision;
      if (D.20176 == D.20205) goto <D.20206>; else goto <D.20207>;
      <D.20206>:
      D.20117 = aname;
      return D.20117;
      <D.20207>:
      <D.20204>:
      <D.20201>:
      <D.20198>:
      D.20182 = aname->major;
      D.20180 = aname->minor;
      D.20208 = D.20182 | D.20180;
      D.20178 = aname->build;
      D.20209 = D.20208 | D.20178;
      D.20176 = aname->revision;
      D.20210 = D.20209 | D.20176;
      if (D.20210 != 0) goto <D.20211>; else goto <D.20212>;
      <D.20211>:
      D.20205 = vset->revision;
      D.20213 = (int) D.20205;
      D.20202 = vset->build;
      D.20214 = (int) D.20202;
      D.20199 = vset->minor;
      D.20215 = (int) D.20199;
      D.20196 = vset->major;
      D.20216 = (int) D.20196;
      D.20176 = aname->revision;
      D.20177 = (int) D.20176;
      D.20178 = aname->build;
      D.20179 = (int) D.20178;
      D.20180 = aname->minor;
      D.20181 = (int) D.20180;
      D.20182 = aname->major;
      D.20183 = (int) D.20182;
      D.20114 = aname->name;
      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.20114, D.20183, D.20181, D.20179, D.20177, D.20216, D.20215, D.20214, D.20213);
      <D.20212>:
      memcpy (dest_aname, aname, 80);
      D.20196 = vset->major;
      dest_aname->major = D.20196;
      D.20199 = vset->minor;
      dest_aname->minor = D.20199;
      D.20202 = vset->build;
      dest_aname->build = D.20202;
      D.20205 = vset->revision;
      dest_aname->revision = D.20205;
      D.20117 = dest_aname;
      return D.20117;
    }
    <D.20188>:
    if (res < 0) goto <D.20217>; else goto <D.20218>;
    <D.20217>:
    last = pos + -1;
    goto <D.20219>;
    <D.20218>:
    first = pos + 1;
    <D.20219>:
  }
  <D.17615>:
  if (first <= last) goto <D.17614>; else goto <D.17616>;
  <D.17616>:
  D.20117 = aname;
  return D.20117;
}


remap_keys (struct MonoAssemblyName * aname)
{
  int D.17579;
  const char * D.20223;
  const char * D.20224;
  const char * D.20226;
  mono_byte[17] * D.20227;
  int D.20228;
  const char * D.20229;
  unsigned int i.70;
  int i;

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

    entry = &key_remap_table[i];
    {
      size_t __s1_len;
      size_t __s2_len;

      D.20223 = entry->name;
      D.20224 = aname->name;
      D.17579 = __builtin_strcmp (D.20224, D.20223);
    }
    if (D.17579 != 0) goto <D.20221>; else goto <D.20225>;
    <D.20225>:
    D.20226 = entry->from;
    D.20227 = &aname->public_key_token;
    D.20228 = mono_public_tokens_are_equal (D.20227, D.20226);
    if (D.20228 == 0) goto <D.20221>; else goto <D.20222>;
    <D.20221>:
    // predicted unlikely by continue predictor.
    goto <D.17580>;
    <D.20222>:
    D.20229 = entry->to;
    D.20227 = &aname->public_key_token;
    memcpy (D.20227, D.20229, 17);
    D.20229 = entry->to;
    D.20226 = entry->from;
    D.20224 = aname->name;
    mono_trace (64, 1, "Remapped public key token of retargetable assembly %s from %s to %s", D.20224, D.20226, D.20229);
    return;
  }
  <D.17580>:
  i = i + 1;
  <D.17582>:
  i.70 = (unsigned int) i;
  if (i.70 <= 13) goto <D.17581>; else goto <D.17583>;
  <D.17583>:
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.20232;
  long unsigned int D.20233;

  D.20233 = __builtin_object_size (__dest, 0);
  D.20232 = __builtin___memcpy_chk (__dest, __src, __len, D.20233);
  return D.20232;
}


invoke_assembly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<Tf36>) (struct MonoAssemblyName *, char * *, void *) D.20235;
  void * D.20236;
  struct MonoAssembly * D.20239;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_preload_hook;
  goto <D.17744>;
  <D.17743>:
  D.20235 = hook->func;
  D.20236 = hook->user_data;
  assembly = D.20235 (aname, assemblies_path, D.20236);
  if (assembly != 0B) goto <D.20237>; else goto <D.20238>;
  <D.20237>:
  D.20239 = assembly;
  return D.20239;
  <D.20238>:
  hook = hook->next;
  <D.17744>:
  if (hook != 0B) goto <D.17743>; else goto <D.17745>;
  <D.17745>:
  D.20239 = 0B;
  return D.20239;
}


probe_for_partial_name (const char * basepath, const char * fullname, struct MonoAssemblyName * aname, MonoImageOpenStatus * status)
{
  struct MonoAssembly * D.20243;
  short unsigned int D.20244;
  short unsigned int D.20245;
  short unsigned int D.20246;
  short unsigned int D.20247;
  short unsigned int D.20248;
  short unsigned int D.20249;
  short unsigned int D.20250;
  _Bool D.20251;
  const char * D.20252;
  int D.20253;
  const char * D.20256;
  int D.18083;
  const char * D.20259;
  mono_byte[17] * D.20264;
  char D.20265;
  int D.20268;
  long unsigned int D.20275;
  long unsigned int D.20276;
  long unsigned int D.20277;
  long unsigned int D.20278;
  _Bool D.20279;
  short unsigned int D.20281;
  int D.20282;
  short unsigned int D.20288;
  int D.20289;
  short unsigned int D.20295;
  int D.20296;
  short unsigned int D.20302;
  int D.20303;
  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.20241>; else goto <D.20242>;
      <D.20241>:
      D.20243 = 0B;
      return D.20243;
      <D.20242>:
      D.20244 = aname->major;
      D.20245 = aname->minor;
      D.20246 = D.20244 | D.20245;
      D.20247 = aname->build;
      D.20248 = D.20246 | D.20247;
      D.20249 = aname->revision;
      D.20250 = D.20248 | D.20249;
      D.20251 = D.20250 != 0;
      exact_version = (gboolean) D.20251;
      goto <D.18074>;
      <D.18084>:
      {
        gboolean match;

        match = 1;
        D.20252 = aname->name;
        D.20253 = parse_assembly_directory_name (D.20252, direntry, &gac_aname);
        if (D.20253 == 0) goto <D.20254>; else goto <D.20255>;
        <D.20254>:
        // predicted unlikely by continue predictor.
        goto <D.18074>;
        <D.20255>:
        D.20256 = aname->culture;
        if (D.20256 != 0B) goto <D.20257>; else goto <D.20258>;
        <D.20257>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.20259 = gac_aname.culture;
          D.20256 = aname->culture;
          D.18083 = __builtin_strcmp (D.20256, D.20259);
        }
        if (D.18083 != 0) goto <D.20260>; else goto <D.20261>;
        <D.20260>:
        match = 0;
        <D.20261>:
        <D.20258>:
        if (match != 0) goto <D.20262>; else goto <D.20263>;
        <D.20262>:
        D.20264 = &aname->public_key_token;
        D.20265 = MEM[(const char *)D.20264];
        if (D.20265 != 0) goto <D.20266>; else goto <D.20267>;
        <D.20266>:
        D.20264 = &aname->public_key_token;
        D.20268 = mono_public_tokens_are_equal (D.20264, &gac_aname.public_key_token);
        if (D.20268 == 0) goto <D.20269>; else goto <D.20270>;
        <D.20269>:
        match = 0;
        <D.20270>:
        <D.20267>:
        <D.20263>:
        if (match != 0) goto <D.20271>; else goto <D.20272>;
        <D.20271>:
        if (exact_version != 0) goto <D.20273>; else goto <D.20274>;
        <D.20273>:
        D.20275 = BIT_FIELD_REF <*aname, 64, 512>;
        D.20276 = D.20275;
        D.20277 = BIT_FIELD_REF <gac_aname, 64, 512>;
        D.20278 = D.20277;
        D.20279 = D.20276 == D.20278;
        match = (gboolean) D.20279;
        goto <D.20280>;
        <D.20274>:
        D.20281 = gac_aname.major;
        D.20282 = (int) D.20281;
        if (D.20282 < major) goto <D.20283>; else goto <D.20284>;
        <D.20283>:
        match = 0;
        goto <D.20285>;
        <D.20284>:
        D.20281 = gac_aname.major;
        D.20282 = (int) D.20281;
        if (D.20282 == major) goto <D.20286>; else goto <D.20287>;
        <D.20286>:
        D.20288 = gac_aname.minor;
        D.20289 = (int) D.20288;
        if (D.20289 < minor) goto <D.20290>; else goto <D.20291>;
        <D.20290>:
        match = 0;
        goto <D.20292>;
        <D.20291>:
        D.20288 = gac_aname.minor;
        D.20289 = (int) D.20288;
        if (D.20289 == minor) goto <D.20293>; else goto <D.20294>;
        <D.20293>:
        D.20295 = gac_aname.build;
        D.20296 = (int) D.20295;
        if (D.20296 < build) goto <D.20297>; else goto <D.20298>;
        <D.20297>:
        match = 0;
        goto <D.20299>;
        <D.20298>:
        D.20295 = gac_aname.build;
        D.20296 = (int) D.20295;
        if (D.20296 == build) goto <D.20300>; else goto <D.20301>;
        <D.20300>:
        D.20302 = gac_aname.revision;
        D.20303 = (int) D.20302;
        if (D.20303 <= revision) goto <D.20304>; else goto <D.20305>;
        <D.20304>:
        match = 0;
        <D.20305>:
        <D.20301>:
        <D.20299>:
        <D.20294>:
        <D.20292>:
        <D.20287>:
        <D.20285>:
        <D.20280>:
        <D.20272>:
        if (match != 0) goto <D.20306>; else goto <D.20307>;
        <D.20306>:
        D.20281 = gac_aname.major;
        major = (gint) D.20281;
        D.20288 = gac_aname.minor;
        minor = (gint) D.20288;
        D.20295 = gac_aname.build;
        build = (gint) D.20295;
        D.20302 = gac_aname.revision;
        revision = (gint) D.20302;
        monoeg_g_free (fullpath);
        fullpath = monoeg_g_build_path ("/", basepath, direntry, fullname, 0B);
        <D.20307>:
        mono_assembly_name_free (&gac_aname);
      }
      <D.18074>:
      direntry = monoeg_g_dir_read_name (dirhandle);
      if (direntry != 0B) goto <D.18084>; else goto <D.18085>;
      <D.18085>:
      monoeg_g_dir_close (dirhandle);
      if (fullpath == 0B) goto <D.20308>; else goto <D.20309>;
      <D.20308>:
      D.20243 = 0B;
      return D.20243;
      <D.20309>:
      {
        struct MonoAssembly * res;

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


parse_assembly_directory_name (const char * name, const char * dirname, struct MonoAssemblyName * aname)
{
  gchar * D.20315;
  gchar * * D.20317;
  gchar * D.20318;
  gchar * * D.20320;
  gchar * D.20321;
  gboolean D.20322;
  gchar * * parts;
  gboolean res;

  parts = monoeg_g_strsplit (dirname, "_", 3);
  if (parts == 0B) goto <D.20312>; else goto <D.20314>;
  <D.20314>:
  D.20315 = *parts;
  if (D.20315 == 0B) goto <D.20312>; else goto <D.20316>;
  <D.20316>:
  D.20317 = parts + 8;
  D.20318 = *D.20317;
  if (D.20318 == 0B) goto <D.20312>; else goto <D.20319>;
  <D.20319>:
  D.20320 = parts + 16;
  D.20321 = *D.20320;
  if (D.20321 == 0B) goto <D.20312>; else goto <D.20313>;
  <D.20312>:
  monoeg_g_strfreev (parts);
  D.20322 = 0;
  return D.20322;
  <D.20313>:
  D.20320 = parts + 16;
  D.20321 = *D.20320;
  D.20317 = parts + 8;
  D.20318 = *D.20317;
  D.20315 = *parts;
  res = build_assembly_name (name, D.20315, D.20318, D.20321, 0B, 0, 0, aname, 0);
  monoeg_g_strfreev (parts);
  D.20322 = res;
  return D.20322;
}


mono_assembly_load_corlib (const struct MonoRuntimeInfo * runtime, MonoImageOpenStatus * status)
{
  struct MonoAssembly * corlib.71;
  struct MonoAssembly * D.20327;
  char * * assemblies_path.72;
  struct MonoAssembly * corlib.73;
  struct MonoAssembly * corlib.74;
  const char[4] * D.20337;
  struct MonoAssembly * corlib.75;
  struct MonoAssembly * corlib.76;
  int D.18288;
  int iftmp.77;
  int D.18287;
  const char[4] * D.20349;
  unsigned char D.20350;
  int D.20351;
  unsigned char D.20352;
  int D.20353;
  _Bool D.20354;
  _Bool D.20355;
  _Bool D.20356;
  const unsigned char * D.20359;
  unsigned char D.20360;
  int D.20361;
  const unsigned char * D.20362;
  unsigned char D.20363;
  int D.20364;
  _Bool D.20365;
  _Bool D.20366;
  const unsigned char * D.20369;
  unsigned char D.20370;
  int D.20371;
  const unsigned char * D.20372;
  unsigned char D.20373;
  int D.20374;
  _Bool D.20375;
  _Bool D.20376;
  const unsigned char * D.20379;
  unsigned char D.20380;
  int D.20381;
  const unsigned char * D.20382;
  unsigned char D.20383;
  int D.20384;
  const char * D.20388;
  gchar * D.20389;
  char * corlib_file;
  struct MonoAssemblyName * aname;

  corlib.71 = corlib;
  if (corlib.71 != 0B) goto <D.20325>; else goto <D.20326>;
  <D.20325>:
  D.20327 = corlib;
  return D.20327;
  <D.20326>:
  aname = mono_assembly_name_new ("mscorlib.dll");
  assemblies_path.72 = assemblies_path;
  corlib.73 = invoke_assembly_preload_hook (aname, assemblies_path.72);
  corlib = corlib.73;
  mono_assembly_name_free (aname);
  monoeg_g_free (aname);
  corlib.71 = corlib;
  if (corlib.71 != 0B) goto <D.20330>; else goto <D.20331>;
  <D.20330>:
  D.20327 = corlib;
  return D.20327;
  <D.20331>:
  assemblies_path.72 = assemblies_path;
  if (assemblies_path.72 != 0B) goto <D.20332>; else goto <D.20333>;
  <D.20332>:
  assemblies_path.72 = assemblies_path;
  corlib.74 = load_in_path ("mscorlib.dll", assemblies_path.72, status, 0);
  corlib = corlib.74;
  corlib.71 = corlib;
  if (corlib.71 != 0B) goto <D.20335>; else goto <D.20336>;
  <D.20335>:
  D.20327 = corlib;
  return D.20327;
  <D.20336>:
  <D.20333>:
  D.20337 = &runtime->framework_version;
  corlib_file = monoeg_g_build_path ("/", "mono", D.20337, "mscorlib.dll", 0B);
  assemblies_path.72 = assemblies_path;
  if (assemblies_path.72 != 0B) goto <D.20338>; else goto <D.20339>;
  <D.20338>:
  assemblies_path.72 = assemblies_path;
  corlib.75 = load_in_path (corlib_file, assemblies_path.72, status, 0);
  corlib = corlib.75;
  corlib.71 = corlib;
  if (corlib.71 != 0B) goto <D.20341>; else goto <D.20342>;
  <D.20341>:
  monoeg_g_free (corlib_file);
  D.20327 = corlib;
  return D.20327;
  <D.20342>:
  <D.20339>:
  corlib.76 = load_in_path (corlib_file, &default_path, status, 0);
  corlib = corlib.76;
  monoeg_g_free (corlib_file);
  corlib.71 = corlib;
  if (corlib.71 != 0B) goto <D.20344>; else goto <D.20345>;
  <D.20344>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.20347>; else goto <D.20348>;
    <D.20347>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = &runtime->framework_version;
      D.20349 = "4.5";
      D.20350 = MEM[(const unsigned char *)D.20349];
      D.20351 = (int) D.20350;
      D.20352 = *__s2;
      D.20353 = (int) D.20352;
      __result = D.20351 - D.20353;
      {
        D.20354 = __s2_len != 0;
        D.20355 = __result == 0;
        D.20356 = D.20354 & D.20355;
        if (D.20356 != 0) goto <D.20357>; else goto <D.20358>;
        <D.20357>:
        D.20359 = &MEM[(void *)"4.5" + 1B];
        D.20360 = *D.20359;
        D.20361 = (int) D.20360;
        D.20362 = __s2 + 1;
        D.20363 = *D.20362;
        D.20364 = (int) D.20363;
        __result = D.20361 - D.20364;
        D.20365 = __s2_len > 1;
        D.20355 = __result == 0;
        D.20366 = D.20365 & D.20355;
        if (D.20366 != 0) goto <D.20367>; else goto <D.20368>;
        <D.20367>:
        D.20369 = &MEM[(void *)"4.5" + 2B];
        D.20370 = *D.20369;
        D.20371 = (int) D.20370;
        D.20372 = __s2 + 2;
        D.20373 = *D.20372;
        D.20374 = (int) D.20373;
        __result = D.20371 - D.20374;
        D.20375 = __s2_len > 2;
        D.20355 = __result == 0;
        D.20376 = D.20375 & D.20355;
        if (D.20376 != 0) goto <D.20377>; else goto <D.20378>;
        <D.20377>:
        D.20379 = &MEM[(void *)"4.5" + 3B];
        D.20380 = *D.20379;
        D.20381 = (int) D.20380;
        D.20382 = __s2 + 3;
        D.20383 = *D.20382;
        D.20384 = (int) D.20383;
        __result = D.20381 - D.20384;
        <D.20378>:
        <D.20368>:
        <D.20358>:
      }
      D.18287 = __result;
    }
    iftmp.77 = -D.18287;
    goto <D.20385>;
    <D.20348>:
    D.20337 = &runtime->framework_version;
    iftmp.77 = __builtin_strcmp (D.20337, "4.5");
    <D.20385>:
    D.18288 = iftmp.77;
  }
  if (D.18288 == 0) goto <D.20386>; else goto <D.20387>;
  <D.20386>:
  D.20388 = default_path[0];
  D.20389 = monoeg_g_strdup_printf ("%s/mono/4.5/Facades", D.20388);
  default_path[1] = D.20389;
  <D.20387>:
  <D.20345>:
  D.20327 = corlib;
  return D.20327;
}


load_in_path (const char * basename, const char * * search_path, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  long unsigned int D.20391;
  long unsigned int D.20392;
  const char * * D.20393;
  const char * D.20394;
  int D.20395;
  struct MonoAssembly * D.20398;
  int i;
  char * fullpath;
  struct MonoAssembly * result;

  i = 0;
  goto <D.17413>;
  <D.17412>:
  D.20391 = (long unsigned int) i;
  D.20392 = D.20391 * 8;
  D.20393 = search_path + D.20392;
  D.20394 = *D.20393;
  fullpath = monoeg_g_build_path ("/", D.20394, basename, 0B);
  D.20395 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.20395);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.20396>; else goto <D.20397>;
  <D.20396>:
  D.20398 = result;
  return D.20398;
  <D.20397>:
  i = i + 1;
  <D.17413>:
  D.20391 = (long unsigned int) i;
  D.20392 = D.20391 * 8;
  D.20393 = search_path + D.20392;
  D.20394 = *D.20393;
  if (D.20394 != 0B) goto <D.17412>; else goto <D.17414>;
  <D.17414>:
  D.20398 = 0B;
  return D.20398;
}


mono_assembly_load_full_nosearch (struct MonoAssemblyName * aname, const char * basedir, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.20404;
  struct MonoAssembly * iftmp.78;
  char * * assemblies_path.79;
  int D.18311;
  int iftmp.80;
  int D.18310;
  const char[9] * D.20417;
  unsigned char D.20418;
  int D.20419;
  unsigned char D.20420;
  int D.20421;
  _Bool D.20422;
  _Bool D.20423;
  _Bool D.20424;
  const unsigned char * D.20427;
  unsigned char D.20428;
  int D.20429;
  const unsigned char * D.20430;
  unsigned char D.20431;
  int D.20432;
  _Bool D.20433;
  _Bool D.20434;
  const unsigned char * D.20437;
  unsigned char D.20438;
  int D.20439;
  const unsigned char * D.20440;
  unsigned char D.20441;
  int D.20442;
  _Bool D.20443;
  _Bool D.20444;
  const unsigned char * D.20447;
  unsigned char D.20448;
  int D.20449;
  const unsigned char * D.20450;
  unsigned char D.20451;
  int D.20452;
  const char * D.20454;
  int D.18320;
  int iftmp.81;
  int D.18319;
  const char[13] * D.20459;
  unsigned char D.20460;
  int D.20461;
  unsigned char D.20462;
  int D.20463;
  _Bool D.20464;
  _Bool D.20465;
  _Bool D.20466;
  const unsigned char * D.20469;
  unsigned char D.20470;
  int D.20471;
  const unsigned char * D.20472;
  unsigned char D.20473;
  int D.20474;
  _Bool D.20475;
  _Bool D.20476;
  const unsigned char * D.20479;
  unsigned char D.20480;
  int D.20481;
  const unsigned char * D.20482;
  unsigned char D.20483;
  int D.20484;
  _Bool D.20485;
  _Bool D.20486;
  const unsigned char * D.20489;
  unsigned char D.20490;
  int D.20491;
  const unsigned char * D.20492;
  unsigned char D.20493;
  int D.20494;
  const struct MonoRuntimeInfo * D.20496;
  long unsigned int D.20497;
  const char * iftmp.82;
  int D.18329;
  int iftmp.83;
  int D.18328;
  sizetype D.20509;
  sizetype D.20510;
  const char[5] * D.20511;
  unsigned char D.20512;
  int D.20513;
  unsigned char D.20514;
  int D.20515;
  _Bool D.20516;
  _Bool D.20517;
  _Bool D.20518;
  const unsigned char * D.20521;
  unsigned char D.20522;
  int D.20523;
  const unsigned char * D.20524;
  unsigned char D.20525;
  int D.20526;
  _Bool D.20527;
  _Bool D.20528;
  const unsigned char * D.20531;
  unsigned char D.20532;
  int D.20533;
  const unsigned char * D.20534;
  unsigned char D.20535;
  int D.20536;
  _Bool D.20537;
  _Bool D.20538;
  const unsigned char * D.20541;
  unsigned char D.20542;
  int D.20543;
  const unsigned char * D.20544;
  unsigned char D.20545;
  int D.20546;
  const char * D.20548;
  int D.18338;
  int iftmp.84;
  int D.18337;
  const char[5] * D.20553;
  unsigned char D.20554;
  int D.20555;
  unsigned char D.20556;
  int D.20557;
  _Bool D.20558;
  _Bool D.20559;
  _Bool D.20560;
  const unsigned char * D.20563;
  unsigned char D.20564;
  int D.20565;
  const unsigned char * D.20566;
  unsigned char D.20567;
  int D.20568;
  _Bool D.20569;
  _Bool D.20570;
  const unsigned char * D.20573;
  unsigned char D.20574;
  int D.20575;
  const unsigned char * D.20576;
  unsigned char D.20577;
  int D.20578;
  _Bool D.20579;
  _Bool D.20580;
  const unsigned char * D.20583;
  unsigned char D.20584;
  int D.20585;
  const unsigned char * D.20586;
  unsigned char D.20587;
  int D.20588;
  unsigned char D.20590;
  int D.20591;
  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.20400>; else goto <D.20401>;
      <D.20400>:
      aname = mono_assembly_apply_binding (aname, &maped_name_pp);
      <D.20401>:
      result = mono_assembly_loaded_full (aname, refonly);
      if (result != 0B) goto <D.20402>; else goto <D.20403>;
      <D.20402>:
      D.20404 = result;
      return D.20404;
      <D.20403>:
      if (refonly != 0) goto <D.20406>; else goto <D.20407>;
      <D.20406>:
      assemblies_path.79 = assemblies_path;
      iftmp.78 = invoke_assembly_refonly_preload_hook (aname, assemblies_path.79);
      goto <D.20409>;
      <D.20407>:
      assemblies_path.79 = assemblies_path;
      iftmp.78 = invoke_assembly_preload_hook (aname, assemblies_path.79);
      <D.20409>:
      result = iftmp.78;
      if (result != 0B) goto <D.20410>; else goto <D.20411>;
      <D.20410>:
      result->in_gac = 0;
      D.20404 = result;
      return D.20404;
      <D.20411>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.20415>; else goto <D.20416>;
        <D.20415>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = aname->name;
          D.20417 = "mscorlib";
          D.20418 = MEM[(const unsigned char *)D.20417];
          D.20419 = (int) D.20418;
          D.20420 = *__s2;
          D.20421 = (int) D.20420;
          __result = D.20419 - D.20421;
          {
            D.20422 = __s2_len != 0;
            D.20423 = __result == 0;
            D.20424 = D.20422 & D.20423;
            if (D.20424 != 0) goto <D.20425>; else goto <D.20426>;
            <D.20425>:
            D.20427 = &MEM[(void *)"mscorlib" + 1B];
            D.20428 = *D.20427;
            D.20429 = (int) D.20428;
            D.20430 = __s2 + 1;
            D.20431 = *D.20430;
            D.20432 = (int) D.20431;
            __result = D.20429 - D.20432;
            D.20433 = __s2_len > 1;
            D.20423 = __result == 0;
            D.20434 = D.20433 & D.20423;
            if (D.20434 != 0) goto <D.20435>; else goto <D.20436>;
            <D.20435>:
            D.20437 = &MEM[(void *)"mscorlib" + 2B];
            D.20438 = *D.20437;
            D.20439 = (int) D.20438;
            D.20440 = __s2 + 2;
            D.20441 = *D.20440;
            D.20442 = (int) D.20441;
            __result = D.20439 - D.20442;
            D.20443 = __s2_len > 2;
            D.20423 = __result == 0;
            D.20444 = D.20443 & D.20423;
            if (D.20444 != 0) goto <D.20445>; else goto <D.20446>;
            <D.20445>:
            D.20447 = &MEM[(void *)"mscorlib" + 3B];
            D.20448 = *D.20447;
            D.20449 = (int) D.20448;
            D.20450 = __s2 + 3;
            D.20451 = *D.20450;
            D.20452 = (int) D.20451;
            __result = D.20449 - D.20452;
            <D.20446>:
            <D.20436>:
            <D.20426>:
          }
          D.18310 = __result;
        }
        iftmp.80 = -D.18310;
        goto <D.20453>;
        <D.20416>:
        D.20454 = aname->name;
        iftmp.80 = __builtin_strcmp (D.20454, "mscorlib");
        <D.20453>:
        D.18311 = iftmp.80;
      }
      if (D.18311 == 0) goto <D.20412>; else goto <D.20455>;
      <D.20455>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.20457>; else goto <D.20458>;
        <D.20457>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = aname->name;
          D.20459 = "mscorlib.dll";
          D.20460 = MEM[(const unsigned char *)D.20459];
          D.20461 = (int) D.20460;
          D.20462 = *__s2;
          D.20463 = (int) D.20462;
          __result = D.20461 - D.20463;
          {
            D.20464 = __s2_len != 0;
            D.20465 = __result == 0;
            D.20466 = D.20464 & D.20465;
            if (D.20466 != 0) goto <D.20467>; else goto <D.20468>;
            <D.20467>:
            D.20469 = &MEM[(void *)"mscorlib.dll" + 1B];
            D.20470 = *D.20469;
            D.20471 = (int) D.20470;
            D.20472 = __s2 + 1;
            D.20473 = *D.20472;
            D.20474 = (int) D.20473;
            __result = D.20471 - D.20474;
            D.20475 = __s2_len > 1;
            D.20465 = __result == 0;
            D.20476 = D.20475 & D.20465;
            if (D.20476 != 0) goto <D.20477>; else goto <D.20478>;
            <D.20477>:
            D.20479 = &MEM[(void *)"mscorlib.dll" + 2B];
            D.20480 = *D.20479;
            D.20481 = (int) D.20480;
            D.20482 = __s2 + 2;
            D.20483 = *D.20482;
            D.20484 = (int) D.20483;
            __result = D.20481 - D.20484;
            D.20485 = __s2_len > 2;
            D.20465 = __result == 0;
            D.20486 = D.20485 & D.20465;
            if (D.20486 != 0) goto <D.20487>; else goto <D.20488>;
            <D.20487>:
            D.20489 = &MEM[(void *)"mscorlib.dll" + 3B];
            D.20490 = *D.20489;
            D.20491 = (int) D.20490;
            D.20492 = __s2 + 3;
            D.20493 = *D.20492;
            D.20494 = (int) D.20493;
            __result = D.20491 - D.20494;
            <D.20488>:
            <D.20478>:
            <D.20468>:
          }
          D.18319 = __result;
        }
        iftmp.81 = -D.18319;
        goto <D.20495>;
        <D.20458>:
        D.20454 = aname->name;
        iftmp.81 = __builtin_strcmp (D.20454, "mscorlib.dll");
        <D.20495>:
        D.18320 = iftmp.81;
      }
      if (D.18320 == 0) goto <D.20412>; else goto <D.20413>;
      <D.20412>:
      D.20496 = mono_get_runtime_info ();
      D.20404 = mono_assembly_load_corlib (D.20496, status);
      return D.20404;
      <D.20413>:
      D.20454 = aname->name;
      D.20497 = strlen (D.20454);
      len = (int) D.20497;
      ext_index = 0;
      goto <D.18340>;
      <D.18339>:
      if (ext_index == 0) goto <D.20499>; else goto <D.20500>;
      <D.20499>:
      iftmp.82 = ".dll";
      goto <D.20501>;
      <D.20500>:
      iftmp.82 = ".exe";
      <D.20501>:
      ext = iftmp.82;
      if (len > 4) goto <D.20505>; else goto <D.20502>;
      <D.20505>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 4;
        if (__s2_len <= 3) goto <D.20507>; else goto <D.20508>;
        <D.20507>:
        {
          const unsigned char * __s2;
          int __result;

          D.20454 = aname->name;
          D.20509 = (sizetype) len;
          D.20510 = D.20509 + 18446744073709551612;
          __s2 = D.20454 + D.20510;
          D.20511 = ".dll";
          D.20512 = MEM[(const unsigned char *)D.20511];
          D.20513 = (int) D.20512;
          D.20514 = *__s2;
          D.20515 = (int) D.20514;
          __result = D.20513 - D.20515;
          {
            D.20516 = __s2_len != 0;
            D.20517 = __result == 0;
            D.20518 = D.20516 & D.20517;
            if (D.20518 != 0) goto <D.20519>; else goto <D.20520>;
            <D.20519>:
            D.20521 = &MEM[(void *)".dll" + 1B];
            D.20522 = *D.20521;
            D.20523 = (int) D.20522;
            D.20524 = __s2 + 1;
            D.20525 = *D.20524;
            D.20526 = (int) D.20525;
            __result = D.20523 - D.20526;
            D.20527 = __s2_len > 1;
            D.20517 = __result == 0;
            D.20528 = D.20527 & D.20517;
            if (D.20528 != 0) goto <D.20529>; else goto <D.20530>;
            <D.20529>:
            D.20531 = &MEM[(void *)".dll" + 2B];
            D.20532 = *D.20531;
            D.20533 = (int) D.20532;
            D.20534 = __s2 + 2;
            D.20535 = *D.20534;
            D.20536 = (int) D.20535;
            __result = D.20533 - D.20536;
            D.20537 = __s2_len > 2;
            D.20517 = __result == 0;
            D.20538 = D.20537 & D.20517;
            if (D.20538 != 0) goto <D.20539>; else goto <D.20540>;
            <D.20539>:
            D.20541 = &MEM[(void *)".dll" + 3B];
            D.20542 = *D.20541;
            D.20543 = (int) D.20542;
            D.20544 = __s2 + 3;
            D.20545 = *D.20544;
            D.20546 = (int) D.20545;
            __result = D.20543 - D.20546;
            <D.20540>:
            <D.20530>:
            <D.20520>:
          }
          D.18328 = __result;
        }
        iftmp.83 = -D.18328;
        goto <D.20547>;
        <D.20508>:
        D.20454 = aname->name;
        D.20509 = (sizetype) len;
        D.20510 = D.20509 + 18446744073709551612;
        D.20548 = D.20454 + D.20510;
        iftmp.83 = __builtin_strcmp (D.20548, ".dll");
        <D.20547>:
        D.18329 = iftmp.83;
      }
      if (D.18329 == 0) goto <D.20503>; else goto <D.20549>;
      <D.20549>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 4;
        if (__s2_len <= 3) goto <D.20551>; else goto <D.20552>;
        <D.20551>:
        {
          const unsigned char * __s2;
          int __result;

          D.20454 = aname->name;
          D.20509 = (sizetype) len;
          D.20510 = D.20509 + 18446744073709551612;
          __s2 = D.20454 + D.20510;
          D.20553 = ".exe";
          D.20554 = MEM[(const unsigned char *)D.20553];
          D.20555 = (int) D.20554;
          D.20556 = *__s2;
          D.20557 = (int) D.20556;
          __result = D.20555 - D.20557;
          {
            D.20558 = __s2_len != 0;
            D.20559 = __result == 0;
            D.20560 = D.20558 & D.20559;
            if (D.20560 != 0) goto <D.20561>; else goto <D.20562>;
            <D.20561>:
            D.20563 = &MEM[(void *)".exe" + 1B];
            D.20564 = *D.20563;
            D.20565 = (int) D.20564;
            D.20566 = __s2 + 1;
            D.20567 = *D.20566;
            D.20568 = (int) D.20567;
            __result = D.20565 - D.20568;
            D.20569 = __s2_len > 1;
            D.20559 = __result == 0;
            D.20570 = D.20569 & D.20559;
            if (D.20570 != 0) goto <D.20571>; else goto <D.20572>;
            <D.20571>:
            D.20573 = &MEM[(void *)".exe" + 2B];
            D.20574 = *D.20573;
            D.20575 = (int) D.20574;
            D.20576 = __s2 + 2;
            D.20577 = *D.20576;
            D.20578 = (int) D.20577;
            __result = D.20575 - D.20578;
            D.20579 = __s2_len > 2;
            D.20559 = __result == 0;
            D.20580 = D.20579 & D.20559;
            if (D.20580 != 0) goto <D.20581>; else goto <D.20582>;
            <D.20581>:
            D.20583 = &MEM[(void *)".exe" + 3B];
            D.20584 = *D.20583;
            D.20585 = (int) D.20584;
            D.20586 = __s2 + 3;
            D.20587 = *D.20586;
            D.20588 = (int) D.20587;
            __result = D.20585 - D.20588;
            <D.20582>:
            <D.20572>:
            <D.20562>:
          }
          D.18337 = __result;
        }
        iftmp.84 = -D.18337;
        goto <D.20589>;
        <D.20552>:
        D.20454 = aname->name;
        D.20509 = (sizetype) len;
        D.20510 = D.20509 + 18446744073709551612;
        D.20548 = D.20454 + D.20510;
        iftmp.84 = __builtin_strcmp (D.20548, ".exe");
        <D.20589>:
        D.18338 = iftmp.84;
      }
      if (D.18338 == 0) goto <D.20503>; else goto <D.20502>;
      <D.20503>:
      D.20454 = aname->name;
      filename = monoeg_strdup (D.20454);
      ext_index = ext_index + 1;
      goto <D.20504>;
      <D.20502>:
      D.20454 = aname->name;
      filename = monoeg_g_strconcat (D.20454, ext, 0B);
      <D.20504>:
      D.20590 = (unsigned char) refonly;
      D.20591 = (int) D.20590;
      result = mono_assembly_load_from_gac (aname, filename, status, D.20591);
      if (result != 0B) goto <D.20592>; else goto <D.20593>;
      <D.20592>:
      monoeg_g_free (filename);
      D.20404 = result;
      return D.20404;
      <D.20593>:
      if (basedir != 0B) goto <D.20594>; else goto <D.20595>;
      <D.20594>:
      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.20596>; else goto <D.20597>;
      <D.20596>:
      result->in_gac = 0;
      monoeg_g_free (filename);
      D.20404 = result;
      return D.20404;
      <D.20597>:
      <D.20595>:
      D.20590 = (unsigned char) refonly;
      D.20591 = (int) D.20590;
      result = load_in_path (filename, &default_path, status, D.20591);
      if (result != 0B) goto <D.20598>; else goto <D.20599>;
      <D.20598>:
      result->in_gac = 0;
      <D.20599>:
      monoeg_g_free (filename);
      if (result != 0B) goto <D.20600>; else goto <D.20601>;
      <D.20600>:
      D.20404 = result;
      return D.20404;
      <D.20601>:
      ext_index = ext_index + 1;
      <D.18340>:
      if (ext_index <= 1) goto <D.18339>; else goto <D.18341>;
      <D.18341>:
      D.20404 = result;
      return D.20404;
    }
  finally
    {
      maped_aname = {CLOBBER};
      maped_name_pp = {CLOBBER};
    }
}


mono_assembly_apply_binding (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  unsigned char D.20604;
  struct MonoAssemblyName * D.20607;
  union mono_mutex_t * D.20610;
  _Bool D.20613;
  long int D.20614;
  long int D.20615;
  _Bool D.20620;
  long int D.20621;
  long int D.20622;
  int D.20627;
  struct MonoAppDomainSetup * D.20632;
  struct MonoString * D.20635;
  _Bool D.20640;
  long int D.20641;
  long int D.20642;
  int D.20645;
  short unsigned int D.20650;
  int D.20651;
  short unsigned int D.20652;
  int D.20653;
  char * D.20658;
  gchar * D.20659;
  char * D.20660;
  gchar * D.20661;
  int D.20662;
  _Bool D.20665;
  long int D.20666;
  long int D.20667;
  unsigned char D.20672;
  unsigned char D.20673;
  const char * D.20680;
  gchar * D.20681;
  const char * D.20682;
  gchar * D.20683;
  mono_byte[17] * D.20684;
  guchar[17] * D.20685;
  struct GSList * loaded_assembly_bindings.85;
  struct GSList * loaded_assembly_bindings.86;
  int D.20694;
  struct MonoAssemblyBindingInfo * info;
  struct MonoAssemblyBindingInfo * info2;
  struct MonoImage * ppimage;
  struct MonoDomain * domain;

  D.20604 = aname->public_key_token[0];
  if (D.20604 == 0) goto <D.20605>; else goto <D.20606>;
  <D.20605>:
  D.20607 = aname;
  return D.20607;
  <D.20606>:
  domain = mono_domain_get ();
  mono_assembly_binding_lock ();
  info = search_binding_loaded (aname);
  mono_assembly_binding_unlock ();
  if (info == 0B) goto <D.20608>; else goto <D.20609>;
  <D.20608>:
  {
    int ret;

    D.20610 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20610);
    if (ret != 0) goto <D.20611>; else goto <D.20612>;
    <D.20611>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20612>:
    D.20613 = ret != 0;
    D.20614 = (long int) D.20613;
    D.20615 = __builtin_expect (D.20614, 0);
    if (D.20615 != 0) goto <D.20616>; else goto <D.20617>;
    <D.20616>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2644, "ret == 0");
    <D.20617>:
  }
  info = get_per_domain_assembly_binding_info (domain, aname);
  {
    int ret;

    D.20610 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20610);
    if (ret != 0) goto <D.20618>; else goto <D.20619>;
    <D.20618>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20619>:
    D.20620 = ret != 0;
    D.20621 = (long int) D.20620;
    D.20622 = __builtin_expect (D.20621, 0);
    if (D.20622 != 0) goto <D.20623>; else goto <D.20624>;
    <D.20623>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2646, "ret == 0");
    <D.20624>:
  }
  <D.20609>:
  if (info != 0B) goto <D.20625>; else goto <D.20626>;
  <D.20625>:
  D.20627 = check_policy_versions (info, aname);
  if (D.20627 == 0) goto <D.20628>; else goto <D.20629>;
  <D.20628>:
  D.20607 = aname;
  return D.20607;
  <D.20629>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.20607 = dest_name;
  return D.20607;
  <D.20626>:
  if (domain != 0B) goto <D.20630>; else goto <D.20631>;
  <D.20630>:
  D.20632 = domain->setup;
  if (D.20632 != 0B) goto <D.20633>; else goto <D.20634>;
  <D.20633>:
  D.20632 = domain->setup;
  D.20635 = D.20632->configuration_file;
  if (D.20635 != 0B) goto <D.20636>; else goto <D.20637>;
  <D.20636>:
  {
    int ret;

    D.20610 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20610);
    if (ret != 0) goto <D.20638>; else goto <D.20639>;
    <D.20638>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20639>:
    D.20640 = ret != 0;
    D.20641 = (long int) D.20640;
    D.20642 = __builtin_expect (D.20641, 0);
    if (D.20642 != 0) goto <D.20643>; else goto <D.20644>;
    <D.20643>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2658, "ret == 0");
    <D.20644>:
  }
  D.20645 = domain->assembly_bindings_parsed;
  if (D.20645 == 0) goto <D.20646>; else goto <D.20647>;
  <D.20646>:
  {
    gchar * domain_config_file_name;
    gchar * domain_config_file_path;

    D.20632 = domain->setup;
    D.20635 = D.20632->configuration_file;
    domain_config_file_name = mono_string_to_utf8 (D.20635);
    domain_config_file_path = mono_portability_find_file (domain_config_file_name, 1);
    if (domain_config_file_path == 0B) goto <D.20648>; else goto <D.20649>;
    <D.20648>:
    domain_config_file_path = domain_config_file_name;
    <D.20649>:
    D.20650 = aname->minor;
    D.20651 = (int) D.20650;
    D.20652 = aname->major;
    D.20653 = (int) D.20652;
    mono_config_parse_assembly_bindings (domain_config_file_path, D.20653, D.20651, domain, assembly_binding_info_parsed);
    domain->assembly_bindings_parsed = 1;
    if (domain_config_file_name != domain_config_file_path) goto <D.20654>; else goto <D.20655>;
    <D.20654>:
    monoeg_g_free (domain_config_file_name);
    <D.20655>:
    monoeg_g_free (domain_config_file_path);
  }
  <D.20647>:
  info2 = get_per_domain_assembly_binding_info (domain, aname);
  if (info2 != 0B) goto <D.20656>; else goto <D.20657>;
  <D.20656>:
  info = monoeg_g_memdup (info2, 80);
  D.20658 = info2->name;
  D.20659 = monoeg_strdup (D.20658);
  info->name = D.20659;
  D.20660 = info2->culture;
  D.20661 = monoeg_strdup (D.20660);
  info->culture = D.20661;
  D.20662 = domain->domain_id;
  info->domain_id = D.20662;
  <D.20657>:
  {
    int ret;

    D.20610 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20610);
    if (ret != 0) goto <D.20663>; else goto <D.20664>;
    <D.20663>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20664>:
    D.20665 = ret != 0;
    D.20666 = (long int) D.20665;
    D.20667 = __builtin_expect (D.20666, 0);
    if (D.20667 != 0) goto <D.20668>; else goto <D.20669>;
    <D.20668>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2682, "ret == 0");
    <D.20669>:
  }
  <D.20637>:
  <D.20634>:
  <D.20631>:
  if (info == 0B) goto <D.20670>; else goto <D.20671>;
  <D.20670>:
  info = monoeg_malloc0 (80);
  D.20652 = aname->major;
  D.20653 = (int) D.20652;
  info->major = D.20653;
  D.20650 = aname->minor;
  D.20651 = (int) D.20650;
  info->minor = D.20651;
  <D.20671>:
  D.20672 = BIT_FIELD_REF <*info, 8, 544>;
  D.20673 = D.20672 & 8;
  if (D.20673 == 0) goto <D.20674>; else goto <D.20675>;
  <D.20674>:
  ppimage = mono_assembly_load_publisher_policy (aname);
  if (ppimage != 0B) goto <D.20676>; else goto <D.20677>;
  <D.20676>:
  get_publisher_policy_info (ppimage, aname, info);
  mono_image_close (ppimage);
  <D.20677>:
  <D.20675>:
  D.20672 = BIT_FIELD_REF <*info, 8, 544>;
  D.20673 = D.20672 & 8;
  if (D.20673 == 0) goto <D.20678>; else goto <D.20679>;
  <D.20678>:
  D.20680 = aname->name;
  D.20681 = monoeg_strdup (D.20680);
  info->name = D.20681;
  D.20682 = aname->culture;
  D.20683 = monoeg_strdup (D.20682);
  info->culture = D.20683;
  D.20684 = &aname->public_key_token;
  D.20685 = &info->public_key_token;
  monoeg_g_strlcpy (D.20685, D.20684, 17);
  <D.20679>:
  mono_assembly_binding_lock ();
  info2 = search_binding_loaded (aname);
  if (info2 != 0B) goto <D.20686>; else goto <D.20687>;
  <D.20686>:
  mono_assembly_binding_info_free (info);
  monoeg_g_free (info);
  info = info2;
  goto <D.20688>;
  <D.20687>:
  loaded_assembly_bindings.85 = loaded_assembly_bindings;
  loaded_assembly_bindings.86 = monoeg_g_slist_prepend (loaded_assembly_bindings.85, info);
  loaded_assembly_bindings = loaded_assembly_bindings.86;
  <D.20688>:
  mono_assembly_binding_unlock ();
  D.20672 = BIT_FIELD_REF <*info, 8, 544>;
  D.20673 = D.20672 & 8;
  if (D.20673 == 0) goto <D.20691>; else goto <D.20693>;
  <D.20693>:
  D.20694 = check_policy_versions (info, aname);
  if (D.20694 == 0) goto <D.20691>; else goto <D.20692>;
  <D.20691>:
  D.20607 = aname;
  return D.20607;
  <D.20692>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.20607 = dest_name;
  return D.20607;
}


assembly_binding_info_parsed (struct MonoAssemblyBindingInfo * info, void * user_data)
{
  int D.18211;
  char * D.20698;
  char * D.20699;
  int D.20702;
  struct MonoMemPool * D.20705;
  char * D.20708;
  char * D.20709;
  char * D.20712;
  struct GSList * D.20713;
  struct GSList * D.20714;
  struct MonoAssemblyBindingInfo * info_copy;
  struct GSList * tmp;
  struct MonoAssemblyBindingInfo * info_tmp;
  struct MonoDomain * domain;

  domain = user_data;
  if (domain == 0B) goto <D.20696>; else goto <D.20697>;
  <D.20696>:
  return;
  <D.20697>:
  tmp = domain->assembly_bindings;
  goto <D.18213>;
  <D.18212>:
  info_tmp = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20698 = info_tmp->name;
    D.20699 = info->name;
    D.18211 = __builtin_strcmp (D.20699, D.20698);
  }
  if (D.18211 == 0) goto <D.20700>; else goto <D.20701>;
  <D.20700>:
  D.20702 = info_versions_equal (info, info_tmp);
  if (D.20702 != 0) goto <D.20703>; else goto <D.20704>;
  <D.20703>:
  return;
  <D.20704>:
  <D.20701>:
  tmp = tmp->next;
  <D.18213>:
  if (tmp != 0B) goto <D.18212>; else goto <D.18214>;
  <D.18214>:
  D.20705 = domain->mp;
  info_copy = mono_mempool_alloc0 (D.20705, 80);
  memcpy (info_copy, info, 80);
  D.20699 = info->name;
  if (D.20699 != 0B) goto <D.20706>; else goto <D.20707>;
  <D.20706>:
  D.20699 = info->name;
  D.20705 = domain->mp;
  D.20708 = mono_mempool_strdup (D.20705, D.20699);
  info_copy->name = D.20708;
  <D.20707>:
  D.20709 = info->culture;
  if (D.20709 != 0B) goto <D.20710>; else goto <D.20711>;
  <D.20710>:
  D.20709 = info->culture;
  D.20705 = domain->mp;
  D.20712 = mono_mempool_strdup (D.20705, D.20709);
  info_copy->culture = D.20712;
  <D.20711>:
  D.20713 = domain->assembly_bindings;
  D.20705 = domain->mp;
  D.20714 = g_slist_append_mempool (D.20705, D.20713, info_copy);
  domain->assembly_bindings = D.20714;
}


info_versions_equal (struct MonoAssemblyBindingInfo * left, struct MonoAssemblyBindingInfo * right)
{
  unsigned char D.20716;
  unsigned char D.20717;
  unsigned char D.20718;
  unsigned char D.20719;
  gboolean D.20722;
  unsigned char D.20723;
  unsigned char D.20726;
  unsigned char D.20729;
  struct AssemblyVersionSet * D.20732;
  struct AssemblyVersionSet * D.20733;
  int D.20734;
  unsigned char D.20737;
  struct AssemblyVersionSet * D.20740;
  struct AssemblyVersionSet * D.20741;
  int D.20742;
  unsigned char D.20745;
  struct AssemblyVersionSet * D.20748;
  struct AssemblyVersionSet * D.20749;
  int D.20750;

  D.20716 = BIT_FIELD_REF <*left, 8, 544>;
  D.20717 = BIT_FIELD_REF <*right, 8, 544>;
  D.20718 = D.20716 ^ D.20717;
  D.20719 = D.20718 & 1;
  if (D.20719 != 0) goto <D.20720>; else goto <D.20721>;
  <D.20720>:
  D.20722 = 0;
  return D.20722;
  <D.20721>:
  D.20716 = BIT_FIELD_REF <*left, 8, 544>;
  D.20717 = BIT_FIELD_REF <*right, 8, 544>;
  D.20718 = D.20716 ^ D.20717;
  D.20723 = D.20718 & 2;
  if (D.20723 != 0) goto <D.20724>; else goto <D.20725>;
  <D.20724>:
  D.20722 = 0;
  return D.20722;
  <D.20725>:
  D.20716 = BIT_FIELD_REF <*left, 8, 544>;
  D.20717 = BIT_FIELD_REF <*right, 8, 544>;
  D.20718 = D.20716 ^ D.20717;
  D.20726 = D.20718 & 4;
  if (D.20726 != 0) goto <D.20727>; else goto <D.20728>;
  <D.20727>:
  D.20722 = 0;
  return D.20722;
  <D.20728>:
  D.20716 = BIT_FIELD_REF <*left, 8, 544>;
  D.20729 = D.20716 & 1;
  if (D.20729 != 0) goto <D.20730>; else goto <D.20731>;
  <D.20730>:
  D.20732 = &right->old_version_bottom;
  D.20733 = &left->old_version_bottom;
  D.20734 = info_compare_versions (D.20733, D.20732);
  if (D.20734 == 0) goto <D.20735>; else goto <D.20736>;
  <D.20735>:
  D.20722 = 0;
  return D.20722;
  <D.20736>:
  <D.20731>:
  D.20716 = BIT_FIELD_REF <*left, 8, 544>;
  D.20737 = D.20716 & 2;
  if (D.20737 != 0) goto <D.20738>; else goto <D.20739>;
  <D.20738>:
  D.20740 = &right->old_version_top;
  D.20741 = &left->old_version_top;
  D.20742 = info_compare_versions (D.20741, D.20740);
  if (D.20742 == 0) goto <D.20743>; else goto <D.20744>;
  <D.20743>:
  D.20722 = 0;
  return D.20722;
  <D.20744>:
  <D.20739>:
  D.20716 = BIT_FIELD_REF <*left, 8, 544>;
  D.20745 = D.20716 & 4;
  if (D.20745 != 0) goto <D.20746>; else goto <D.20747>;
  <D.20746>:
  D.20748 = &right->new_version;
  D.20749 = &left->new_version;
  D.20750 = info_compare_versions (D.20749, D.20748);
  if (D.20750 == 0) goto <D.20751>; else goto <D.20752>;
  <D.20751>:
  D.20722 = 0;
  return D.20722;
  <D.20752>:
  <D.20747>:
  D.20722 = 1;
  return D.20722;
}


info_compare_versions (struct AssemblyVersionSet * left, struct AssemblyVersionSet * right)
{
  short unsigned int D.20756;
  short unsigned int D.20757;
  short unsigned int D.20759;
  short unsigned int D.20760;
  short unsigned int D.20762;
  short unsigned int D.20763;
  short unsigned int D.20765;
  short unsigned int D.20766;
  gboolean D.20767;

  D.20756 = left->major;
  D.20757 = right->major;
  if (D.20756 != D.20757) goto <D.20754>; else goto <D.20758>;
  <D.20758>:
  D.20759 = left->minor;
  D.20760 = right->minor;
  if (D.20759 != D.20760) goto <D.20754>; else goto <D.20761>;
  <D.20761>:
  D.20762 = left->build;
  D.20763 = right->build;
  if (D.20762 != D.20763) goto <D.20754>; else goto <D.20764>;
  <D.20764>:
  D.20765 = left->revision;
  D.20766 = right->revision;
  if (D.20765 != D.20766) goto <D.20754>; else goto <D.20755>;
  <D.20754>:
  D.20767 = 0;
  return D.20767;
  <D.20755>:
  D.20767 = 1;
  return D.20767;
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.20771;
  struct GSList * D.20772;
  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.20769>; else goto <D.20770>;
  <D.20769>:
  last = list;
  goto <D.10819>;
  <D.10818>:
  last = last->next;
  <D.10819>:
  D.20771 = last->next;
  if (D.20771 != 0B) goto <D.10818>; else goto <D.10820>;
  <D.10820>:
  last->next = new_list;
  D.20772 = list;
  return D.20772;
  <D.20770>:
  D.20772 = new_list;
  return D.20772;
}


get_per_domain_assembly_binding_info (struct MonoDomain * domain, struct MonoAssemblyName * aname)
{
  struct GSList * D.20774;
  struct MonoAssemblyBindingInfo * D.20777;
  int D.18238;
  char * D.20780;
  const char * D.20781;
  int D.20784;
  unsigned char D.20791;
  unsigned char D.20793;
  unsigned char D.20794;
  int D.20796;
  struct MonoAssemblyBindingInfo * info;
  struct GSList * list;

  D.20774 = domain->assembly_bindings;
  if (D.20774 == 0B) goto <D.20775>; else goto <D.20776>;
  <D.20775>:
  D.20777 = 0B;
  return D.20777;
  <D.20776>:
  info = 0B;
  list = domain->assembly_bindings;
  goto <D.18241>;
  <D.18240>:
  info = list->data;
  if (info != 0B) goto <D.20778>; else goto <D.20779>;
  <D.20778>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20780 = info->name;
    D.20781 = aname->name;
    D.18238 = __builtin_strcmp (D.20781, D.20780);
  }
  if (D.18238 == 0) goto <D.20782>; else goto <D.20783>;
  <D.20782>:
  D.20784 = info_major_minor_in_range (info, aname);
  if (D.20784 != 0) goto <D.18239>; else goto <D.20785>;
  <D.20785>:
  <D.20783>:
  <D.20779>:
  info = 0B;
  list = list->next;
  <D.18241>:
  if (list != 0B) goto <D.18240>; else goto <D.18239>;
  <D.18239>:
  if (info != 0B) goto <D.20786>; else goto <D.20787>;
  <D.20786>:
  D.20780 = info->name;
  if (D.20780 != 0B) goto <D.20790>; else goto <D.20788>;
  <D.20790>:
  D.20791 = info->public_key_token[0];
  if (D.20791 != 0) goto <D.20792>; else goto <D.20788>;
  <D.20792>:
  D.20793 = BIT_FIELD_REF <*info, 8, 544>;
  D.20794 = D.20793 & 5;
  if (D.20794 == 5) goto <D.20795>; else goto <D.20788>;
  <D.20795>:
  D.20796 = assembly_binding_maps_name (info, aname);
  if (D.20796 != 0) goto <D.20797>; else goto <D.20788>;
  <D.20797>:
  info->is_valid = 1;
  goto <D.20789>;
  <D.20788>:
  info->is_valid = 0;
  <D.20789>:
  <D.20787>:
  D.20777 = info;
  return D.20777;
}


info_major_minor_in_range (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  short unsigned int D.20799;
  int D.20800;
  short unsigned int D.20801;
  int D.20802;
  unsigned char D.20803;
  unsigned char D.20804;
  gboolean D.20807;
  short unsigned int D.20808;
  int D.20809;
  short unsigned int D.20810;
  int D.20811;
  int D.20812;
  unsigned char D.20815;
  short unsigned int D.20818;
  int D.20819;
  short unsigned int D.20820;
  int D.20821;
  int D.20822;
  int aname_version_number;

  D.20799 = aname->minor;
  D.20800 = (int) D.20799;
  D.20801 = aname->major;
  D.20802 = (int) D.20801;
  aname_version_number = get_version_number (D.20802, D.20800);
  D.20803 = BIT_FIELD_REF <*info, 8, 544>;
  D.20804 = D.20803 & 1;
  if (D.20804 == 0) goto <D.20805>; else goto <D.20806>;
  <D.20805>:
  D.20807 = 0;
  return D.20807;
  <D.20806>:
  D.20808 = info->old_version_bottom.minor;
  D.20809 = (int) D.20808;
  D.20810 = info->old_version_bottom.major;
  D.20811 = (int) D.20810;
  D.20812 = get_version_number (D.20811, D.20809);
  if (D.20812 > aname_version_number) goto <D.20813>; else goto <D.20814>;
  <D.20813>:
  D.20807 = 0;
  return D.20807;
  <D.20814>:
  D.20803 = BIT_FIELD_REF <*info, 8, 544>;
  D.20815 = D.20803 & 2;
  if (D.20815 != 0) goto <D.20816>; else goto <D.20817>;
  <D.20816>:
  D.20818 = info->old_version_top.minor;
  D.20819 = (int) D.20818;
  D.20820 = info->old_version_top.major;
  D.20821 = (int) D.20820;
  D.20822 = get_version_number (D.20821, D.20819);
  if (D.20822 < aname_version_number) goto <D.20823>; else goto <D.20824>;
  <D.20823>:
  D.20807 = 0;
  return D.20807;
  <D.20824>:
  <D.20817>:
  D.20801 = aname->major;
  D.20802 = (int) D.20801;
  info->major = D.20802;
  D.20799 = aname->minor;
  D.20800 = (int) D.20799;
  info->minor = D.20800;
  D.20807 = 1;
  return D.20807;
}


get_version_number (int major, int minor)
{
  int D.20826;
  int D.20827;

  D.20827 = major * 256;
  D.20826 = D.20827 + minor;
  return D.20826;
}


assembly_binding_maps_name (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  char * D.20832;
  gboolean D.20833;
  int D.17350;
  const char * D.20834;
  int D.20839;
  short unsigned int D.20840;
  int D.20841;
  int D.20843;
  short unsigned int D.20844;
  int D.20845;
  int iftmp.87;
  char * D.20849;
  char D.20851;
  _Bool D.20853;
  int iftmp.88;
  const char * D.20857;
  char D.20859;
  _Bool D.20861;
  _Bool D.20862;
  int D.17359;
  mono_byte[17] * D.20871;
  guchar[17] * D.20872;
  int D.20873;

  if (info == 0B) goto <D.20829>; else goto <D.20831>;
  <D.20831>:
  D.20832 = info->name;
  if (D.20832 == 0B) goto <D.20829>; else goto <D.20830>;
  <D.20829>:
  D.20833 = 0;
  return D.20833;
  <D.20830>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20834 = aname->name;
    D.20832 = info->name;
    D.17350 = __builtin_strcmp (D.20832, D.20834);
  }
  if (D.17350 != 0) goto <D.20835>; else goto <D.20836>;
  <D.20835>:
  D.20833 = 0;
  return D.20833;
  <D.20836>:
  D.20839 = info->major;
  D.20840 = aname->major;
  D.20841 = (int) D.20840;
  if (D.20839 != D.20841) goto <D.20837>; else goto <D.20842>;
  <D.20842>:
  D.20843 = info->minor;
  D.20844 = aname->minor;
  D.20845 = (int) D.20844;
  if (D.20843 != D.20845) goto <D.20837>; else goto <D.20838>;
  <D.20837>:
  D.20833 = 0;
  return D.20833;
  <D.20838>:
  D.20849 = info->culture;
  if (D.20849 != 0B) goto <D.20850>; else goto <D.20847>;
  <D.20850>:
  D.20849 = info->culture;
  D.20851 = *D.20849;
  if (D.20851 != 0) goto <D.20852>; else goto <D.20847>;
  <D.20852>:
  iftmp.87 = 1;
  goto <D.20848>;
  <D.20847>:
  iftmp.87 = 0;
  <D.20848>:
  D.20853 = (_Bool) iftmp.87;
  D.20857 = aname->culture;
  if (D.20857 != 0B) goto <D.20858>; else goto <D.20855>;
  <D.20858>:
  D.20857 = aname->culture;
  D.20859 = *D.20857;
  if (D.20859 != 0) goto <D.20860>; else goto <D.20855>;
  <D.20860>:
  iftmp.88 = 1;
  goto <D.20856>;
  <D.20855>:
  iftmp.88 = 0;
  <D.20856>:
  D.20861 = (_Bool) iftmp.88;
  D.20862 = D.20853 ^ D.20861;
  if (D.20862 != 0) goto <D.20863>; else goto <D.20864>;
  <D.20863>:
  D.20833 = 0;
  return D.20833;
  <D.20864>:
  D.20849 = info->culture;
  if (D.20849 != 0B) goto <D.20865>; else goto <D.20866>;
  <D.20865>:
  D.20857 = aname->culture;
  if (D.20857 != 0B) goto <D.20867>; else goto <D.20868>;
  <D.20867>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20857 = aname->culture;
    D.20849 = info->culture;
    D.17359 = __builtin_strcmp (D.20849, D.20857);
  }
  if (D.17359 != 0) goto <D.20869>; else goto <D.20870>;
  <D.20869>:
  D.20833 = 0;
  return D.20833;
  <D.20870>:
  <D.20868>:
  <D.20866>:
  D.20871 = &aname->public_key_token;
  D.20872 = &info->public_key_token;
  D.20873 = mono_public_tokens_are_equal (D.20872, D.20871);
  if (D.20873 == 0) goto <D.20874>; else goto <D.20875>;
  <D.20874>:
  D.20833 = 0;
  return D.20833;
  <D.20875>:
  D.20833 = 1;
  return D.20833;
}


mono_assembly_load_publisher_policy (struct MonoAssemblyName * aname)
{
  const char * D.20877;
  char * D.20878;
  long unsigned int D.20881;
  unsigned int D.20882;
  unsigned int D.20883;
  long unsigned int D.20884;
  long unsigned int D.20885;
  const char * D.20887;
  short unsigned int D.20891;
  int D.20892;
  short unsigned int D.20893;
  int D.20894;
  mono_byte[17] * D.20895;
  char * * extra_gac_paths.89;
  gchar * D.20899;
  struct MonoImage * D.20903;
  const char * D.20904;
  struct MonoImage * image;
  gchar * filename;
  gchar * pname;
  gchar * name;
  gchar * culture;
  gchar * version;
  gchar * fullpath;
  gchar * subpath;
  gchar * * paths;
  gint32 len;

  D.20877 = aname->name;
  D.20878 = strstr (D.20877, ".dll");
  if (D.20878 != 0B) goto <D.20879>; else goto <D.20880>;
  <D.20879>:
  D.20877 = aname->name;
  D.20881 = strlen (D.20877);
  D.20882 = (unsigned int) D.20881;
  D.20883 = D.20882 + 4294967292;
  len = (gint32) D.20883;
  D.20884 = (long unsigned int) len;
  name = monoeg_malloc (D.20884);
  D.20885 = (long unsigned int) len;
  D.20877 = aname->name;
  strncpy (name, D.20877, D.20885);
  goto <D.20886>;
  <D.20880>:
  D.20877 = aname->name;
  name = monoeg_strdup (D.20877);
  <D.20886>:
  D.20887 = aname->culture;
  if (D.20887 != 0B) goto <D.20888>; else goto <D.20889>;
  <D.20888>:
  D.20887 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.20887, -1);
  goto <D.20890>;
  <D.20889>:
  culture = monoeg_strdup ("");
  <D.20890>:
  D.20891 = aname->minor;
  D.20892 = (int) D.20891;
  D.20893 = aname->major;
  D.20894 = (int) D.20893;
  pname = monoeg_g_strdup_printf ("policy.%d.%d.%s", D.20894, D.20892, name);
  D.20895 = &aname->public_key_token;
  version = monoeg_g_strdup_printf ("0.0.0.0_%s_%s", culture, D.20895);
  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.89 = extra_gac_paths;
  if (extra_gac_paths.89 != 0B) goto <D.20897>; else goto <D.20898>;
  <D.20897>:
  paths = extra_gac_paths;
  goto <D.18172>;
  <D.18171>:
  D.20899 = *paths;
  fullpath = monoeg_g_build_path ("/", D.20899, "lib", "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (fullpath);
  paths = paths + 8;
  <D.18172>:
  if (image == 0B) goto <D.20900>; else goto <D.18173>;
  <D.20900>:
  D.20899 = *paths;
  if (D.20899 != 0B) goto <D.18171>; else goto <D.18173>;
  <D.18173>:
  <D.20898>:
  if (image != 0B) goto <D.20901>; else goto <D.20902>;
  <D.20901>:
  monoeg_g_free (subpath);
  D.20903 = image;
  return D.20903;
  <D.20902>:
  D.20904 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.20904, "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (subpath);
  monoeg_g_free (fullpath);
  D.20903 = image;
  return D.20903;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.20906;
  long unsigned int D.20907;

  D.20907 = __builtin_object_size (__dest, 1);
  D.20906 = __builtin___strncpy_chk (__dest, __src, __len, D.20907);
  return D.20906;
}


get_publisher_policy_info (struct MonoImage * image, struct MonoAssemblyName * aname, struct MonoAssemblyBindingInfo * binding_info)
{
  <unnamed-unsigned:24> D.20909;
  int D.20910;
  unsigned int D.20913;
  unsigned int D.20914;
  unsigned int D.20917;
  _Bool D.20918;
  long int D.20919;
  long int D.20920;
  char * D.20923;
  char * D.20924;
  gchar * D.20927;
  char * D.20930;
  unsigned char D.20932;
  unsigned char D.20934;
  unsigned char D.20935;
  int D.20937;
  struct MonoTableInfo * t;
  guint32 cols[4];
  const gchar * filename;
  gchar * subpath;
  gchar * fullpath;

  try
    {
      t = &image->tables[40];
      D.20909 = t->rows;
      D.20910 = (int) D.20909;
      if (D.20910 <= 0) goto <D.20911>; else goto <D.20912>;
      <D.20911>:
      binding_info->is_valid = 0;
      return;
      <D.20912>:
      mono_metadata_decode_row (t, 0, &cols, 4);
      D.20913 = cols[3];
      D.20914 = D.20913 & 3;
      if (D.20914 != 0) goto <D.20915>; else goto <D.20916>;
      <D.20915>:
      binding_info->is_valid = 0;
      return;
      <D.20916>:
      D.20917 = cols[2];
      filename = mono_metadata_string_heap (image, D.20917);
      D.20918 = filename == 0B;
      D.20919 = (long int) D.20918;
      D.20920 = __builtin_expect (D.20919, 0);
      if (D.20920 != 0) goto <D.20921>; else goto <D.20922>;
      <D.20921>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 370, "filename != NULL");
      <D.20922>:
      D.20923 = image->name;
      subpath = monoeg_g_path_get_dirname (D.20923);
      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.20924 = binding_info->culture;
      if (D.20924 == 0B) goto <D.20925>; else goto <D.20926>;
      <D.20925>:
      D.20927 = monoeg_strdup ("");
      binding_info->culture = D.20927;
      <D.20926>:
      D.20930 = binding_info->name;
      if (D.20930 == 0B) goto <D.20928>; else goto <D.20931>;
      <D.20931>:
      D.20932 = binding_info->public_key_token[0];
      if (D.20932 == 0) goto <D.20928>; else goto <D.20933>;
      <D.20933>:
      D.20934 = BIT_FIELD_REF <*binding_info, 8, 544>;
      D.20935 = D.20934 & 5;
      if (D.20935 != 5) goto <D.20928>; else goto <D.20936>;
      <D.20936>:
      D.20937 = assembly_binding_maps_name (binding_info, aname);
      if (D.20937 == 0) goto <D.20928>; else goto <D.20929>;
      <D.20928>:
      mono_assembly_binding_info_free (binding_info);
      binding_info->is_valid = 0;
      return;
      <D.20929>:
      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.20941;
  struct MonoAssemblyBindingInfo * D.20944;
  struct GSList * tmp;

  tmp = loaded_assembly_bindings;
  goto <D.18185>;
  <D.18184>:
  {
    struct MonoAssemblyBindingInfo * info;

    info = tmp->data;
    D.20941 = assembly_binding_maps_name (info, aname);
    if (D.20941 != 0) goto <D.20942>; else goto <D.20943>;
    <D.20942>:
    D.20944 = info;
    return D.20944;
    <D.20943>:
  }
  tmp = tmp->next;
  <D.18185>:
  if (tmp != 0B) goto <D.18184>; else goto <D.18186>;
  <D.18186>:
  D.20944 = 0B;
  return D.20944;
}


mono_assembly_binding_info_free (struct MonoAssemblyBindingInfo * info)
{
  char * D.20948;
  char * D.20949;

  if (info == 0B) goto <D.20946>; else goto <D.20947>;
  <D.20946>:
  return;
  <D.20947>:
  D.20948 = info->name;
  monoeg_g_free (D.20948);
  D.20949 = info->culture;
  monoeg_g_free (D.20949);
}


mono_assembly_binding_unlock ()
{
  pthread_mutex_unlock (&assembly_binding_mutex);
}


check_policy_versions (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * name)
{
  unsigned char D.20951;
  unsigned char D.20952;
  gboolean D.20955;
  unsigned char D.20956;
  struct AssemblyVersionSet * D.20959;
  int D.20960;
  struct AssemblyVersionSet * D.20963;
  int D.20964;
  int D.20967;

  D.20951 = BIT_FIELD_REF <*info, 8, 544>;
  D.20952 = D.20951 & 8;
  if (D.20952 == 0) goto <D.20953>; else goto <D.20954>;
  <D.20953>:
  D.20955 = 0;
  return D.20955;
  <D.20954>:
  D.20951 = BIT_FIELD_REF <*info, 8, 544>;
  D.20956 = D.20951 & 2;
  if (D.20956 == 0) goto <D.20957>; else goto <D.20958>;
  <D.20957>:
  D.20959 = &info->old_version_bottom;
  D.20960 = compare_versions (D.20959, name);
  if (D.20960 == 0) goto <D.20961>; else goto <D.20962>;
  <D.20961>:
  D.20955 = 1;
  return D.20955;
  <D.20962>:
  D.20955 = 0;
  return D.20955;
  <D.20958>:
  D.20963 = &info->old_version_top;
  D.20964 = compare_versions (D.20963, name);
  if (D.20964 < 0) goto <D.20965>; else goto <D.20966>;
  <D.20965>:
  D.20955 = 0;
  return D.20955;
  <D.20966>:
  D.20959 = &info->old_version_bottom;
  D.20967 = compare_versions (D.20959, name);
  if (D.20967 > 0) goto <D.20968>; else goto <D.20969>;
  <D.20968>:
  D.20955 = 0;
  return D.20955;
  <D.20969>:
  D.20955 = 1;
  return D.20955;
}


compare_versions (struct AssemblyVersionSet * v, struct MonoAssemblyName * aname)
{
  short unsigned int D.20971;
  short unsigned int D.20972;
  int D.20975;
  short unsigned int D.20978;
  short unsigned int D.20979;
  short unsigned int D.20984;
  short unsigned int D.20985;
  short unsigned int D.20990;
  short unsigned int D.20991;

  D.20971 = v->major;
  D.20972 = aname->major;
  if (D.20971 > D.20972) goto <D.20973>; else goto <D.20974>;
  <D.20973>:
  D.20975 = 1;
  return D.20975;
  <D.20974>:
  D.20971 = v->major;
  D.20972 = aname->major;
  if (D.20971 < D.20972) goto <D.20976>; else goto <D.20977>;
  <D.20976>:
  D.20975 = -1;
  return D.20975;
  <D.20977>:
  D.20978 = v->minor;
  D.20979 = aname->minor;
  if (D.20978 > D.20979) goto <D.20980>; else goto <D.20981>;
  <D.20980>:
  D.20975 = 1;
  return D.20975;
  <D.20981>:
  D.20978 = v->minor;
  D.20979 = aname->minor;
  if (D.20978 < D.20979) goto <D.20982>; else goto <D.20983>;
  <D.20982>:
  D.20975 = -1;
  return D.20975;
  <D.20983>:
  D.20984 = v->build;
  D.20985 = aname->build;
  if (D.20984 > D.20985) goto <D.20986>; else goto <D.20987>;
  <D.20986>:
  D.20975 = 1;
  return D.20975;
  <D.20987>:
  D.20984 = v->build;
  D.20985 = aname->build;
  if (D.20984 < D.20985) goto <D.20988>; else goto <D.20989>;
  <D.20988>:
  D.20975 = -1;
  return D.20975;
  <D.20989>:
  D.20990 = v->revision;
  D.20991 = aname->revision;
  if (D.20990 > D.20991) goto <D.20992>; else goto <D.20993>;
  <D.20992>:
  D.20975 = 1;
  return D.20975;
  <D.20993>:
  D.20990 = v->revision;
  D.20991 = aname->revision;
  if (D.20990 < D.20991) goto <D.20994>; else goto <D.20995>;
  <D.20994>:
  D.20975 = -1;
  return D.20975;
  <D.20995>:
  D.20975 = 0;
  return D.20975;
}


mono_assembly_bind_version (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  short unsigned int D.20997;
  short unsigned int D.20998;
  short unsigned int D.20999;
  short unsigned int D.21000;
  struct MonoAssemblyName * D.21001;

  memcpy (dest_name, aname, 80);
  D.20997 = info->new_version.major;
  dest_name->major = D.20997;
  D.20998 = info->new_version.minor;
  dest_name->minor = D.20998;
  D.20999 = info->new_version.build;
  dest_name->build = D.20999;
  D.21000 = info->new_version.revision;
  dest_name->revision = D.21000;
  D.21001 = dest_name;
  return D.21001;
}


invoke_assembly_refonly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<Tf36>) (struct MonoAssemblyName *, char * *, void *) D.21003;
  void * D.21004;
  struct MonoAssembly * D.21007;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_refonly_preload_hook;
  goto <D.17753>;
  <D.17752>:
  D.21003 = hook->func;
  D.21004 = hook->user_data;
  assembly = D.21003 (aname, assemblies_path, D.21004);
  if (assembly != 0B) goto <D.21005>; else goto <D.21006>;
  <D.21005>:
  D.21007 = assembly;
  return D.21007;
  <D.21006>:
  hook = hook->next;
  <D.17753>:
  if (hook != 0B) goto <D.17752>; else goto <D.17754>;
  <D.17754>:
  D.21007 = 0B;
  return D.21007;
}


mono_assembly_load_from_gac (struct MonoAssemblyName * aname, gchar * filename, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  unsigned char D.21009;
  struct MonoAssembly * D.21012;
  const char * D.21013;
  char * D.21014;
  long unsigned int D.21017;
  unsigned int D.21018;
  unsigned int D.21019;
  long unsigned int D.21020;
  long unsigned int D.21021;
  const char * D.21023;
  mono_byte[17] * D.21027;
  short unsigned int D.21028;
  int D.21029;
  short unsigned int D.21030;
  int D.21031;
  short unsigned int D.21032;
  int D.21033;
  short unsigned int D.21034;
  int D.21035;
  char * * extra_gac_paths.90;
  gchar * D.21039;
  int D.21040;
  const char * D.21044;
  struct MonoAssembly * result;
  gchar * name;
  gchar * version;
  gchar * culture;
  gchar * fullpath;
  gchar * subpath;
  gint32 len;
  gchar * * paths;
  char * pubtok;

  result = 0B;
  D.21009 = aname->public_key_token[0];
  if (D.21009 == 0) goto <D.21010>; else goto <D.21011>;
  <D.21010>:
  D.21012 = 0B;
  return D.21012;
  <D.21011>:
  D.21013 = aname->name;
  D.21014 = strstr (D.21013, ".dll");
  if (D.21014 != 0B) goto <D.21015>; else goto <D.21016>;
  <D.21015>:
  D.21017 = strlen (filename);
  D.21018 = (unsigned int) D.21017;
  D.21019 = D.21018 + 4294967292;
  len = (gint32) D.21019;
  D.21020 = (long unsigned int) len;
  name = monoeg_malloc (D.21020);
  D.21021 = (long unsigned int) len;
  D.21013 = aname->name;
  strncpy (name, D.21013, D.21021);
  goto <D.21022>;
  <D.21016>:
  D.21013 = aname->name;
  name = monoeg_strdup (D.21013);
  <D.21022>:
  D.21023 = aname->culture;
  if (D.21023 != 0B) goto <D.21024>; else goto <D.21025>;
  <D.21024>:
  D.21023 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.21023, -1);
  goto <D.21026>;
  <D.21025>:
  culture = monoeg_strdup ("");
  <D.21026>:
  D.21027 = &aname->public_key_token;
  pubtok = monoeg_g_ascii_strdown (D.21027, 17);
  D.21028 = aname->revision;
  D.21029 = (int) D.21028;
  D.21030 = aname->build;
  D.21031 = (int) D.21030;
  D.21032 = aname->minor;
  D.21033 = (int) D.21032;
  D.21034 = aname->major;
  D.21035 = (int) D.21034;
  version = monoeg_g_strdup_printf ("%d.%d.%d.%d_%s_%s", D.21035, D.21033, D.21031, D.21029, 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.90 = extra_gac_paths;
  if (extra_gac_paths.90 != 0B) goto <D.21037>; else goto <D.21038>;
  <D.21037>:
  paths = extra_gac_paths;
  goto <D.18272>;
  <D.18271>:
  D.21039 = *paths;
  fullpath = monoeg_g_build_path ("/", D.21039, "lib", "mono", "gac", subpath, 0B);
  D.21040 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.21040);
  monoeg_g_free (fullpath);
  paths = paths + 8;
  <D.18272>:
  if (result == 0B) goto <D.21041>; else goto <D.18273>;
  <D.21041>:
  D.21039 = *paths;
  if (D.21039 != 0B) goto <D.18271>; else goto <D.18273>;
  <D.18273>:
  <D.21038>:
  if (result != 0B) goto <D.21042>; else goto <D.21043>;
  <D.21042>:
  result->in_gac = 1;
  monoeg_g_free (subpath);
  D.21012 = result;
  return D.21012;
  <D.21043>:
  D.21044 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.21044, "mono", "gac", subpath, 0B);
  D.21040 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.21040);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.21045>; else goto <D.21046>;
  <D.21045>:
  result->in_gac = 1;
  <D.21046>:
  monoeg_g_free (subpath);
  D.21012 = result;
  return D.21012;
}


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

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


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

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


mono_assembly_loaded_full (struct MonoAssemblyName * aname, gboolean refonly)
{
  struct MonoAssembly * D.21054;
  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.21054 = res;
      return D.21054;
    }
  finally
    {
      maped_aname = {CLOBBER};
    }
}


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

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


mono_assembly_release_gc_roots (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.21059;
  unsigned char D.21062;
  struct MonoImage * * D.21065;
  long unsigned int D.21066;
  long unsigned int D.21067;
  struct MonoImage * * D.21068;
  struct MonoImage * D.21069;
  unsigned int i.91;
  unsigned int D.21071;

  D.21059 = assembly + 18446744073709551615;
  if (D.21059 > -3B) goto <D.21060>; else goto <D.21061>;
  <D.21060>:
  return;
  <D.21061>:
  D.21062 = assembly->dynamic;
  if (D.21062 != 0) goto <D.21063>; else goto <D.21064>;
  <D.21063>:
  {
    int i;
    struct MonoDynamicImage * dynimg;

    dynimg = assembly->image;
    i = 0;
    goto <D.18369>;
    <D.18368>:
    D.21065 = dynimg->image.modules;
    D.21066 = (long unsigned int) i;
    D.21067 = D.21066 * 8;
    D.21068 = D.21065 + D.21067;
    D.21069 = *D.21068;
    mono_dynamic_image_release_gc_roots (D.21069);
    i = i + 1;
    <D.18369>:
    i.91 = (unsigned int) i;
    D.21071 = dynimg->image.module_count;
    if (i.91 < D.21071) goto <D.18368>; else goto <D.18370>;
    <D.18370>:
    mono_dynamic_image_release_gc_roots (dynimg);
  }
  <D.21064>:
}


mono_assembly_close_except_image_pools (struct MonoAssembly * assembly)
{
  gboolean D.21075;
  int * D.21078;
  int D.21079;
  const char * D.21082;
  struct MonoImage * D.21083;
  _Bool D.21086;
  long int D.21087;
  long int D.21088;
  struct GList * loaded_assemblies.92;
  struct GList * loaded_assemblies.93;
  _Bool D.21095;
  long int D.21096;
  long int D.21097;
  int D.21100;
  struct GSList * D.21103;
  char * D.21104;
  struct GSList * tmp;

  if (assembly == 0B) goto <D.21073>; else goto <D.21074>;
  <D.21073>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 3029, "assembly != NULL");
  D.21075 = 0;
  return D.21075;
  <D.21074>:
  if (assembly == -1B) goto <D.21076>; else goto <D.21077>;
  <D.21076>:
  D.21075 = 0;
  return D.21075;
  <D.21077>:
  D.21078 = &assembly->ref_count;
  D.21079 = InterlockedDecrement (D.21078);
  if (D.21079 > 0) goto <D.21080>; else goto <D.21081>;
  <D.21080>:
  D.21075 = 0;
  return D.21075;
  <D.21081>:
  mono_profiler_assembly_event (assembly, 2);
  D.21082 = assembly->aname.name;
  mono_trace (64, 1, "Unloading assembly %s [%p].", D.21082, assembly);
  D.21083 = assembly->image;
  mono_debug_close_image (D.21083);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21084>; else goto <D.21085>;
    <D.21084>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21085>:
    D.21086 = ret != 0;
    D.21087 = (long int) D.21086;
    D.21088 = __builtin_expect (D.21087, 0);
    if (D.21088 != 0) goto <D.21089>; else goto <D.21090>;
    <D.21089>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3044, "ret == 0");
    <D.21090>:
  }
  loaded_assemblies.92 = loaded_assemblies;
  loaded_assemblies.93 = monoeg_g_list_remove (loaded_assemblies.92, assembly);
  loaded_assemblies = loaded_assemblies.93;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21093>; else goto <D.21094>;
    <D.21093>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21094>:
    D.21095 = ret != 0;
    D.21096 = (long int) D.21095;
    D.21097 = __builtin_expect (D.21096, 0);
    if (D.21097 != 0) goto <D.21098>; else goto <D.21099>;
    <D.21098>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3046, "ret == 0");
    <D.21099>:
  }
  D.21083 = assembly->image;
  D.21083->assembly = 0B;
  D.21083 = assembly->image;
  D.21100 = mono_image_close_except_pools (D.21083);
  if (D.21100 == 0) goto <D.21101>; else goto <D.21102>;
  <D.21101>:
  assembly->image = 0B;
  <D.21102>:
  tmp = assembly->friend_assembly_names;
  goto <D.18379>;
  <D.18378>:
  {
    struct MonoAssemblyName * fname;

    fname = tmp->data;
    mono_assembly_name_free (fname);
    monoeg_g_free (fname);
  }
  tmp = tmp->next;
  <D.18379>:
  if (tmp != 0B) goto <D.18378>; else goto <D.18380>;
  <D.18380>:
  D.21103 = assembly->friend_assembly_names;
  monoeg_g_slist_free (D.21103);
  D.21104 = assembly->basedir;
  monoeg_g_free (D.21104);
  mono_profiler_assembly_event (assembly, 3);
  D.21075 = 1;
  return D.21075;
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.21106;
  unsigned int D.21107;

  D.21107 = __sync_sub_and_fetch_4 (val, 1);
  D.21106 = (gint32) D.21107;
  return D.21106;
}


mono_assembly_close_finish (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.21109;
  _Bool D.21110;
  long int D.21111;
  long int D.21112;
  struct MonoImage * D.21115;
  unsigned char D.21118;
  const char * D.21121;

  D.21109 = assembly + 18446744073709551615;
  D.21110 = D.21109 > -3B;
  D.21111 = (long int) D.21110;
  D.21112 = __builtin_expect (D.21111, 0);
  if (D.21112 != 0) goto <D.21113>; else goto <D.21114>;
  <D.21113>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3069, "assembly && assembly != REFERENCE_MISSING");
  <D.21114>:
  D.21115 = assembly->image;
  if (D.21115 != 0B) goto <D.21116>; else goto <D.21117>;
  <D.21116>:
  D.21115 = assembly->image;
  mono_image_close_finish (D.21115);
  <D.21117>:
  D.21118 = assembly->dynamic;
  if (D.21118 != 0) goto <D.21119>; else goto <D.21120>;
  <D.21119>:
  D.21121 = assembly->aname.culture;
  monoeg_g_free (D.21121);
  goto <D.21122>;
  <D.21120>:
  monoeg_g_free (assembly);
  <D.21122>:
}


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

  D.21123 = mono_assembly_close_except_image_pools (assembly);
  if (D.21123 != 0) goto <D.21124>; else goto <D.21125>;
  <D.21124>:
  mono_assembly_close_finish (assembly);
  <D.21125>:
}


mono_assembly_load_module (struct MonoAssembly * assembly, guint32 idx)
{
  struct MonoImage * D.21126;
  int idx.94;
  struct MonoImage * D.21128;

  idx.94 = (int) idx;
  D.21128 = assembly->image;
  D.21126 = mono_image_load_file_for_image (D.21128, idx.94);
  return D.21126;
}


mono_assembly_foreach (void (*GFunc) (void *, void *) func, void * user_data)
{
  _Bool D.21132;
  long int D.21133;
  long int D.21134;
  struct GList * loaded_assemblies.95;
  _Bool D.21140;
  long int D.21141;
  long int D.21142;
  struct GList * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21130>; else goto <D.21131>;
    <D.21130>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21131>:
    D.21132 = ret != 0;
    D.21133 = (long int) D.21132;
    D.21134 = __builtin_expect (D.21133, 0);
    if (D.21134 != 0) goto <D.21135>; else goto <D.21136>;
    <D.21135>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3110, "ret == 0");
    <D.21136>:
  }
  loaded_assemblies.95 = loaded_assemblies;
  copy = monoeg_g_list_copy (loaded_assemblies.95);
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21138>; else goto <D.21139>;
    <D.21138>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21139>:
    D.21140 = ret != 0;
    D.21141 = (long int) D.21140;
    D.21142 = __builtin_expect (D.21141, 0);
    if (D.21142 != 0) goto <D.21143>; else goto <D.21144>;
    <D.21143>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3112, "ret == 0");
    <D.21144>:
  }
  loaded_assemblies.95 = loaded_assemblies;
  monoeg_g_list_foreach (loaded_assemblies.95, func, user_data);
  monoeg_g_list_free (copy);
}


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

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

    info = l->data;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
  }
  l = l->next;
  <D.18404>:
  if (l != 0B) goto <D.18403>; else goto <D.18405>;
  <D.18405>:
  loaded_assembly_bindings.96 = loaded_assembly_bindings;
  monoeg_g_slist_free (loaded_assembly_bindings.96);
  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>:
}


mono_assembly_cleanup_domain_bindings (guint32 domain_id)
{
  int D.21146;
  unsigned int D.21147;
  struct GSList * D.21150;
  struct GSList * D.21152;
  struct GSList * * iter;

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

    l = *iter;
    info = l->data;
    D.21146 = info->domain_id;
    D.21147 = (unsigned int) D.21146;
    if (D.21147 == domain_id) goto <D.21148>; else goto <D.21149>;
    <D.21148>:
    D.21150 = l->next;
    *iter = D.21150;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
    monoeg_g_slist_free_1 (l);
    goto <D.21151>;
    <D.21149>:
    iter = &l->next;
    <D.21151>:
  }
  <D.18413>:
  D.21152 = *iter;
  if (D.21152 != 0B) goto <D.18412>; else goto <D.18414>;
  <D.18414>:
  mono_assembly_binding_unlock ();
}


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


mono_assembly_get_main ()
{
  struct MonoAssembly * D.21153;

  D.21153 = main_assembly;
  return D.21153;
}


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

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


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


mono_assembly_has_skip_verification (struct MonoAssembly * assembly)
{
  <unnamed-unsigned:2> D.21157;
  int D.21158;
  int D.21159;
  gboolean D.21162;
  int D.21163;
  struct MonoImage * D.21164;
  unsigned int D.21165;
  unsigned int D.21166;
  unsigned int D.21169;
  unsigned int D.21172;
  const char * blob.97;
  const char * blob.98;
  unsigned int D.21175;
  sizetype D.21178;
  const char * D.21179;
  int D.21180;
  <unnamed-unsigned:24> D.21183;
  int D.21184;
  struct MonoTableInfo * t;
  guint32 cols[3];
  const char * blob;
  int i;
  int len;

  try
    {
      D.21157 = assembly->skipverification;
      D.21158 = (int) D.21157;
      D.21159 = D.21158 & 2;
      if (D.21159 != 0) goto <D.21160>; else goto <D.21161>;
      <D.21160>:
      D.21157 = assembly->skipverification;
      D.21163 = (int) D.21157;
      D.21162 = D.21163 & 1;
      return D.21162;
      <D.21161>:
      D.21164 = assembly->image;
      t = &D.21164->tables[14];
      i = 0;
      goto <D.18470>;
      <D.18469>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.21165 = cols[1];
      D.21166 = D.21165 & 3;
      if (D.21166 != 2) goto <D.21167>; else goto <D.21168>;
      <D.21167>:
      // predicted unlikely by continue predictor.
      goto <D.18468>;
      <D.21168>:
      D.21169 = cols[0];
      if (D.21169 != 8) goto <D.21170>; else goto <D.21171>;
      <D.21170>:
      // predicted unlikely by continue predictor.
      goto <D.18468>;
      <D.21171>:
      D.21172 = cols[2];
      D.21164 = assembly->image;
      blob.97 = mono_metadata_blob_heap (D.21164, D.21172);
      blob = blob.97;
      blob.98 = blob;
      D.21175 = mono_metadata_decode_blob_size (blob.98, &blob);
      len = (int) D.21175;
      if (len == 0) goto <D.21176>; else goto <D.21177>;
      <D.21176>:
      // predicted unlikely by continue predictor.
      goto <D.18468>;
      <D.21177>:
      blob.98 = blob;
      D.21178 = (sizetype) len;
      D.21179 = blob.98 + D.21178;
      blob.98 = blob;
      D.21180 = mono_assembly_try_decode_skip_verification (blob.98, D.21179);
      if (D.21180 != 0) goto <D.21181>; else goto <D.21182>;
      <D.21181>:
      assembly->skipverification = 3;
      D.21162 = 1;
      return D.21162;
      <D.21182>:
      <D.18468>:
      i = i + 1;
      <D.18470>:
      D.21183 = t->rows;
      D.21184 = (int) D.21183;
      if (D.21184 > i) goto <D.18469>; else goto <D.18471>;
      <D.18471>:
      assembly->skipverification = 2;
      D.21162 = 0;
      return D.21162;
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
    }
}


mono_assembly_try_decode_skip_verification (const char * p, const char * endn)
{
  const char * p.99;
  char D.21188;
  long int endn.100;
  long int p.101;
  long int D.21193;
  char * D.21196;
  _Bool D.21197;
  gboolean D.21198;
  const char * p.102;
  const char * p.103;
  char D.21201;
  unsigned int D.21204;
  unsigned int D.21205;
  int iftmp.104;
  unsigned int len.105;
  int D.21211;
  sizetype D.21213;
  const char * p.106;
  unsigned int D.21215;
  sizetype D.21218;
  unsigned int D.21219;
  int D.21220;
  int abort_decoding.107;
  const char * p.108;
  int i;
  int j;
  int num;
  int len;
  int params_len;

  p.99 = p;
  D.21188 = *p.99;
  if (D.21188 == 60) goto <D.21189>; else goto <D.21190>;
  <D.21189>:
  {
    gsize read;
    gsize written;
    char * res;

    try
      {
        endn.100 = (long int) endn;
        p.99 = p;
        p.101 = (long int) p.99;
        D.21193 = endn.100 - p.101;
        p.99 = p;
        res = monoeg_g_convert (p.99, D.21193, "UTF-8", "UTF-16LE", &read, &written, 0B);
        if (res != 0B) goto <D.21194>; else goto <D.21195>;
        <D.21194>:
        {
          gboolean found;

          D.21196 = strstr (res, "\"SkipVerification\"");
          D.21197 = D.21196 != 0B;
          found = (gboolean) D.21197;
          monoeg_g_free (res);
          D.21198 = found;
          return D.21198;
        }
        <D.21195>:
        D.21198 = 0;
        return D.21198;
      }
    finally
      {
        read = {CLOBBER};
        written = {CLOBBER};
      }
  }
  <D.21190>:
  p.99 = p;
  p.102 = p.99;
  p.103 = p.102 + 1;
  p = p.103;
  D.21201 = *p.102;
  if (D.21201 != 46) goto <D.21202>; else goto <D.21203>;
  <D.21202>:
  D.21198 = 0;
  return D.21198;
  <D.21203>:
  p.99 = p;
  D.21204 = mono_metadata_decode_value (p.99, &p);
  num = (int) D.21204;
  i = 0;
  goto <D.18458>;
  <D.18457>:
  {
    gboolean is_valid;
    gboolean abort_decoding;

    try
      {
        is_valid = 0;
        abort_decoding = 0;
        p.99 = p;
        D.21205 = mono_metadata_decode_value (p.99, &p);
        len = (int) D.21205;
        len.105 = (unsigned int) len;
        if (len.105 > 54) goto <D.21210>; else goto <D.21207>;
        <D.21210>:
        p.99 = p;
        D.21211 = memcmp (p.99, "System.Security.Permissions.SecurityPermissionAttribute", 55);
        if (D.21211 == 0) goto <D.21212>; else goto <D.21207>;
        <D.21212>:
        iftmp.104 = 1;
        goto <D.21208>;
        <D.21207>:
        iftmp.104 = 0;
        <D.21208>:
        is_valid = iftmp.104;
        p.99 = p;
        D.21213 = (sizetype) len;
        p.106 = p.99 + D.21213;
        p = p.106;
        p.99 = p;
        D.21215 = mono_metadata_decode_value (p.99, &p);
        params_len = (int) D.21215;
        if (is_valid != 0) goto <D.21216>; else goto <D.21217>;
        <D.21216>:
        {
          const char * params_end;

          p.99 = p;
          D.21218 = (sizetype) params_len;
          params_end = p.99 + D.21218;
          p.99 = p;
          D.21219 = mono_metadata_decode_value (p.99, &p);
          len = (int) D.21219;
          j = 0;
          goto <D.18456>;
          <D.18455>:
          p.99 = p;
          D.21220 = mono_assembly_try_decode_skip_verification_param (p.99, &p, &abort_decoding);
          if (D.21220 != 0) goto <D.21221>; else goto <D.21222>;
          <D.21221>:
          D.21198 = 1;
          return D.21198;
          <D.21222>:
          abort_decoding.107 = abort_decoding;
          if (abort_decoding.107 != 0) goto <D.18454>; else goto <D.21224>;
          <D.21224>:
          j = j + 1;
          <D.18456>:
          if (j < len) goto <D.18455>; else goto <D.18454>;
          <D.18454>:
          p = params_end;
        }
        goto <D.21225>;
        <D.21217>:
        p.99 = p;
        D.21218 = (sizetype) params_len;
        p.108 = p.99 + D.21218;
        p = p.108;
        <D.21225>:
      }
    finally
      {
        abort_decoding = {CLOBBER};
      }
  }
  i = i + 1;
  <D.18458>:
  if (i < num) goto <D.18457>; else goto <D.18459>;
  <D.18459>:
  D.21198 = 0;
  return D.21198;
}


mono_assembly_try_decode_skip_verification_param (const char * p, const char * * resp, gboolean * abort_decoding)
{
  const char * p.109;
  const char * p.110;
  const char * p.111;
  char D.21234;
  int D.21235;
  gboolean D.21236;
  const char * p.112;
  const char * p.113;
  char D.21239;
  unsigned int D.21242;
  unsigned int len.114;
  int D.21246;
  sizetype D.21249;
  const char * p.115;
  char D.21251;
  sizetype D.21252;
  const char * p.116;
  int len;

  p.109 = p;
  p.110 = p.109;
  p.111 = p.110 + 1;
  p = p.111;
  D.21234 = *p.110;
  D.21235 = (int) D.21234;
  switch (D.21235) <default: <D.18437>, case 83: <D.18436>, case 84: <D.18434>>
  <D.18434>:
  goto <D.18435>;
  <D.18436>:
  <D.18437>:
  *abort_decoding = 1;
  D.21236 = 0;
  return D.21236;
  <D.18435>:
  p.109 = p;
  p.112 = p.109;
  p.113 = p.112 + 1;
  p = p.113;
  D.21239 = *p.112;
  if (D.21239 != 2) goto <D.21240>; else goto <D.21241>;
  <D.21240>:
  *abort_decoding = 1;
  D.21236 = 0;
  return D.21236;
  <D.21241>:
  p.109 = p;
  D.21242 = mono_metadata_decode_value (p.109, &p);
  len = (int) D.21242;
  len.114 = (unsigned int) len;
  if (len.114 > 15) goto <D.21244>; else goto <D.21245>;
  <D.21244>:
  p.109 = p;
  D.21246 = memcmp (p.109, "SkipVerification", 16);
  if (D.21246 == 0) goto <D.21247>; else goto <D.21248>;
  <D.21247>:
  p.109 = p;
  D.21249 = (sizetype) len;
  p.115 = p.109 + D.21249;
  p = p.115;
  p.109 = p;
  D.21251 = *p.109;
  D.21236 = (gboolean) D.21251;
  return D.21236;
  <D.21248>:
  <D.21245>:
  p.109 = p;
  D.21249 = (sizetype) len;
  D.21252 = D.21249 + 1;
  p.116 = p.109 + D.21252;
  p = p.116;
  p.109 = p;
  *resp = p.109;
  D.21236 = 0;
  return D.21236;
}