mono_public_tokens_are_equal (const unsigned char * pubt1, const unsigned char * pubt2)
{
  gboolean D.20682;
  int D.20683;
  _Bool D.20684;

  D.20683 = memcmp (pubt1, pubt2, 16);
  D.20684 = D.20683 == 0;
  D.20682 = (gboolean) D.20684;
  return D.20682;
}


mono_set_assemblies_path (const char * path)
{
  char * * assemblies_path.0;
  char * D.20689;
  char D.20690;
  char * * dest.1;
  const gchar * D.20694;
  int D.20699;
  char * * splitted;
  char * * dest;

  splitted = monoeg_g_strsplit (path, ":", 1000);
  assemblies_path.0 = assemblies_path;
  if (assemblies_path.0 != 0B) goto <D.20687>; else goto <D.20688>;
  <D.20687>:
  assemblies_path.0 = assemblies_path;
  monoeg_g_strfreev (assemblies_path.0);
  <D.20688>:
  dest = splitted;
  assemblies_path = dest;
  goto <D.19524>;
  <D.19523>:
  D.20689 = *splitted;
  D.20690 = *D.20689;
  if (D.20690 != 0) goto <D.20691>; else goto <D.20692>;
  <D.20691>:
  dest.1 = dest;
  dest = dest.1 + 4;
  D.20689 = *splitted;
  *dest.1 = D.20689;
  <D.20692>:
  splitted = splitted + 4;
  <D.19524>:
  D.20689 = *splitted;
  if (D.20689 != 0B) goto <D.19523>; else goto <D.19525>;
  <D.19525>:
  D.20689 = *splitted;
  *dest = D.20689;
  D.20694 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.20694 == 0B) goto <D.20695>; else goto <D.20696>;
  <D.20695>:
  return;
  <D.20696>:
  splitted = assemblies_path;
  goto <D.19527>;
  <D.19526>:
  D.20689 = *splitted;
  D.20690 = *D.20689;
  if (D.20690 != 0) goto <D.20697>; else goto <D.20698>;
  <D.20697>:
  D.20689 = *splitted;
  D.20699 = monoeg_g_file_test (D.20689, 4);
  if (D.20699 == 0) goto <D.20700>; else goto <D.20701>;
  <D.20700>:
  D.20689 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_PATH doesn\'t exist or has wrong permissions.", D.20689);
  <D.20701>:
  <D.20698>:
  splitted = splitted + 4;
  <D.19527>:
  D.20689 = *splitted;
  if (D.20689 != 0B) goto <D.19526>; else goto <D.19528>;
  <D.19528>:
}


mono_assembly_names_equal (struct MonoAssemblyName * l, struct MonoAssemblyName * r)
{
  const char * D.20705;
  const char * D.20707;
  mono_bool D.20708;
  int D.19600;
  const char * D.20711;
  const char * D.20714;
  int D.19609;
  unsigned int D.20721;
  unsigned int D.20722;
  unsigned int D.20723;
  unsigned int D.20724;
  unsigned int D.20726;
  unsigned int D.20727;
  unsigned int D.20728;
  unsigned int D.20729;
  unsigned char D.20737;
  unsigned char D.20739;
  mono_byte[17] * D.20740;
  mono_byte[17] * D.20741;
  int D.20742;

  D.20705 = l->name;
  if (D.20705 == 0B) goto <D.20703>; else goto <D.20706>;
  <D.20706>:
  D.20707 = r->name;
  if (D.20707 == 0B) goto <D.20703>; else goto <D.20704>;
  <D.20703>:
  D.20708 = 0;
  return D.20708;
  <D.20704>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20705 = l->name;
    D.20707 = r->name;
    D.19600 = __builtin_strcmp (D.20705, D.20707);
  }
  if (D.19600 != 0) goto <D.20709>; else goto <D.20710>;
  <D.20709>:
  D.20708 = 0;
  return D.20708;
  <D.20710>:
  D.20711 = l->culture;
  if (D.20711 != 0B) goto <D.20712>; else goto <D.20713>;
  <D.20712>:
  D.20714 = r->culture;
  if (D.20714 != 0B) goto <D.20715>; else goto <D.20716>;
  <D.20715>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20711 = l->culture;
    D.20714 = r->culture;
    D.19609 = __builtin_strcmp (D.20711, D.20714);
  }
  if (D.19609 != 0) goto <D.20717>; else goto <D.20718>;
  <D.20717>:
  D.20708 = 0;
  return D.20708;
  <D.20718>:
  <D.20716>:
  <D.20713>:
  D.20721 = BIT_FIELD_REF <*l, 32, 384>;
  D.20722 = D.20721;
  D.20723 = BIT_FIELD_REF <*r, 32, 384>;
  D.20724 = D.20723;
  if (D.20722 != D.20724) goto <D.20719>; else goto <D.20725>;
  <D.20725>:
  D.20726 = BIT_FIELD_REF <*l, 32, 416>;
  D.20727 = D.20726;
  D.20728 = BIT_FIELD_REF <*r, 32, 416>;
  D.20729 = D.20728;
  if (D.20727 != D.20729) goto <D.20719>; else goto <D.20720>;
  <D.20719>:
  D.20721 = BIT_FIELD_REF <*l, 32, 384>;
  D.20722 = D.20721;
  if (D.20722 != 0) goto <D.20732>; else goto <D.20733>;
  <D.20733>:
  D.20726 = BIT_FIELD_REF <*l, 32, 416>;
  D.20727 = D.20726;
  if (D.20727 != 0) goto <D.20732>; else goto <D.20731>;
  <D.20732>:
  D.20723 = BIT_FIELD_REF <*r, 32, 384>;
  D.20724 = D.20723;
  if (D.20724 != 0) goto <D.20730>; else goto <D.20734>;
  <D.20734>:
  D.20728 = BIT_FIELD_REF <*r, 32, 416>;
  D.20729 = D.20728;
  if (D.20729 != 0) goto <D.20730>; else goto <D.20731>;
  <D.20730>:
  D.20708 = 0;
  return D.20708;
  <D.20731>:
  <D.20720>:
  D.20737 = l->public_key_token[0];
  if (D.20737 == 0) goto <D.20735>; else goto <D.20738>;
  <D.20738>:
  D.20739 = r->public_key_token[0];
  if (D.20739 == 0) goto <D.20735>; else goto <D.20736>;
  <D.20735>:
  D.20708 = 1;
  return D.20708;
  <D.20736>:
  D.20740 = &l->public_key_token;
  D.20741 = &r->public_key_token;
  D.20742 = mono_public_tokens_are_equal (D.20740, D.20741);
  if (D.20742 == 0) goto <D.20743>; else goto <D.20744>;
  <D.20743>:
  D.20708 = 0;
  return D.20708;
  <D.20744>:
  D.20708 = 1;
  return D.20708;
}


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

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


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

  if (str != 0B) goto <D.20747>; else goto <D.20748>;
  <D.20747>:
  D.20749 = __strdup (str);
  return D.20749;
  <D.20748>:
  D.20749 = 0B;
  return D.20749;
}


mono_assembly_getrootdir ()
{
  const char * D.20751;

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


mono_set_dirs (const char * assembly_dir, const char * config_dir)
{
  if (assembly_dir == 0B) goto <D.20753>; else goto <D.20754>;
  <D.20753>:
  assembly_dir = "/usr/lib";
  <D.20754>:
  if (config_dir == 0B) goto <D.20755>; else goto <D.20756>;
  <D.20755>:
  config_dir = "/etc";
  <D.20756>:
  mono_assembly_setrootdir (assembly_dir);
  mono_set_config_dir (config_dir);
}


mono_set_rootdir ()
{
  int D.20759;
  char buf[4096];
  int s;
  char * str;

  try
    {
      s = readlink ("/proc/self/exe", &buf, 4095);
      if (s != -1) goto <D.20757>; else goto <D.20758>;
      <D.20757>:
      buf[s] = 0;
      set_dirs (&buf);
      return;
      <D.20758>:
      D.20759 = getpid ();
      str = monoeg_g_strdup_printf ("/proc/%d/path/a.out", D.20759);
      s = readlink (str, &buf, 4095);
      monoeg_g_free (str);
      if (s != -1) goto <D.20760>; else goto <D.20761>;
      <D.20760>:
      buf[s] = 0;
      set_dirs (&buf);
      return;
      <D.20761>:
      fallback ();
    }
  finally
    {
      buf = {CLOBBER};
    }
}


readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  unsigned int D.20765;
  int D.20768;
  ssize_t D.20771;
  unsigned int D.20772;
  unsigned int D.20773;
  unsigned int D.20776;

  D.20765 = __builtin_object_size (__buf, 1);
  if (D.20765 != 4294967295) goto <D.20766>; else goto <D.20767>;
  <D.20766>:
  D.20768 = __builtin_constant_p (__len);
  if (D.20768 == 0) goto <D.20769>; else goto <D.20770>;
  <D.20769>:
  D.20772 = __builtin_object_size (__buf, 1);
  D.20771 = __readlink_chk (__path, __buf, __len, D.20772);
  return D.20771;
  <D.20770>:
  D.20773 = __builtin_object_size (__buf, 1);
  if (D.20773 < __len) goto <D.20774>; else goto <D.20775>;
  <D.20774>:
  D.20776 = __builtin_object_size (__buf, 1);
  D.20771 = __readlink_chk_warn (__path, __buf, __len, D.20776);
  return D.20771;
  <D.20775>:
  <D.20767>:
  D.20771 = __readlink_alias (__path, __buf, __len);
  return D.20771;
}


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

  try
    {
      D.20780 = strncmp (exe, "/usr/bin/", 9);
      if (D.20780 == 0) goto <D.20778>; else goto <D.20781>;
      <D.20781>:
      base = compute_base (exe);
      if (base == 0B) goto <D.20778>; else goto <D.20779>;
      <D.20778>:
      fallback ();
      return;
      <D.20779>:
      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.20782 = stat (mono, &buf);
      if (D.20782 == -1) goto <D.20783>; else goto <D.20784>;
      <D.20783>:
      fallback ();
      goto <D.20785>;
      <D.20784>:
      mono_set_dirs (lib, config);
      <D.20785>:
      monoeg_g_free (config);
      monoeg_g_free (lib);
      monoeg_g_free (mono);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


compute_base (char * path)
{
  char * D.20791;
  int D.19644;
  int iftmp.2;
  int D.19643;
  const char[6] * D.20795;
  unsigned char D.20796;
  int D.20797;
  unsigned char D.20798;
  int D.20799;
  _Bool D.20800;
  _Bool D.20801;
  _Bool D.20802;
  const unsigned char * D.20805;
  unsigned char D.20806;
  int D.20807;
  const unsigned char * D.20808;
  unsigned char D.20809;
  int D.20810;
  _Bool D.20811;
  _Bool D.20812;
  const unsigned char * D.20815;
  unsigned char D.20816;
  int D.20817;
  const unsigned char * D.20818;
  unsigned char D.20819;
  int D.20820;
  _Bool D.20821;
  _Bool D.20822;
  const unsigned char * D.20825;
  unsigned char D.20826;
  int D.20827;
  const unsigned char * D.20828;
  unsigned char D.20829;
  int D.20830;
  int D.19653;
  int iftmp.3;
  int D.19652;
  const char[11] * D.20837;
  unsigned char D.20838;
  int D.20839;
  unsigned char D.20840;
  int D.20841;
  _Bool D.20842;
  _Bool D.20843;
  _Bool D.20844;
  const unsigned char * D.20847;
  unsigned char D.20848;
  int D.20849;
  const unsigned char * D.20850;
  unsigned char D.20851;
  int D.20852;
  _Bool D.20853;
  _Bool D.20854;
  const unsigned char * D.20857;
  unsigned char D.20858;
  int D.20859;
  const unsigned char * D.20860;
  unsigned char D.20861;
  int D.20862;
  _Bool D.20863;
  _Bool D.20864;
  const unsigned char * D.20867;
  unsigned char D.20868;
  int D.20869;
  const unsigned char * D.20870;
  unsigned char D.20871;
  int D.20872;
  int D.19662;
  int iftmp.4;
  int D.19661;
  const char[8] * D.20879;
  unsigned char D.20880;
  int D.20881;
  unsigned char D.20882;
  int D.20883;
  _Bool D.20884;
  _Bool D.20885;
  _Bool D.20886;
  const unsigned char * D.20889;
  unsigned char D.20890;
  int D.20891;
  const unsigned char * D.20892;
  unsigned char D.20893;
  int D.20894;
  _Bool D.20895;
  _Bool D.20896;
  const unsigned char * D.20899;
  unsigned char D.20900;
  int D.20901;
  const unsigned char * D.20902;
  unsigned char D.20903;
  int D.20904;
  _Bool D.20905;
  _Bool D.20906;
  const unsigned char * D.20909;
  unsigned char D.20910;
  int D.20911;
  const unsigned char * D.20912;
  unsigned char D.20913;
  int D.20914;
  int D.19671;
  int iftmp.5;
  int D.19670;
  const char[9] * D.20921;
  unsigned char D.20922;
  int D.20923;
  unsigned char D.20924;
  int D.20925;
  _Bool D.20926;
  _Bool D.20927;
  _Bool D.20928;
  const unsigned char * D.20931;
  unsigned char D.20932;
  int D.20933;
  const unsigned char * D.20934;
  unsigned char D.20935;
  int D.20936;
  _Bool D.20937;
  _Bool D.20938;
  const unsigned char * D.20941;
  unsigned char D.20942;
  int D.20943;
  const unsigned char * D.20944;
  unsigned char D.20945;
  int D.20946;
  _Bool D.20947;
  _Bool D.20948;
  const unsigned char * D.20951;
  unsigned char D.20952;
  int D.20953;
  const unsigned char * D.20954;
  unsigned char D.20955;
  int D.20956;
  int D.19680;
  int iftmp.6;
  int D.19679;
  const char[6] * D.20963;
  unsigned char D.20964;
  int D.20965;
  unsigned char D.20966;
  int D.20967;
  _Bool D.20968;
  _Bool D.20969;
  _Bool D.20970;
  const unsigned char * D.20973;
  unsigned char D.20974;
  int D.20975;
  const unsigned char * D.20976;
  unsigned char D.20977;
  int D.20978;
  _Bool D.20979;
  _Bool D.20980;
  const unsigned char * D.20983;
  unsigned char D.20984;
  int D.20985;
  const unsigned char * D.20986;
  unsigned char D.20987;
  int D.20988;
  _Bool D.20989;
  _Bool D.20990;
  const unsigned char * D.20993;
  unsigned char D.20994;
  int D.20995;
  const unsigned char * D.20996;
  unsigned char D.20997;
  int D.20998;
  int D.19689;
  int iftmp.7;
  int D.19688;
  const char[10] * D.21005;
  unsigned char D.21006;
  int D.21007;
  unsigned char D.21008;
  int D.21009;
  _Bool D.21010;
  _Bool D.21011;
  _Bool D.21012;
  const unsigned char * D.21015;
  unsigned char D.21016;
  int D.21017;
  const unsigned char * D.21018;
  unsigned char D.21019;
  int D.21020;
  _Bool D.21021;
  _Bool D.21022;
  const unsigned char * D.21025;
  unsigned char D.21026;
  int D.21027;
  const unsigned char * D.21028;
  unsigned char D.21029;
  int D.21030;
  _Bool D.21031;
  _Bool D.21032;
  const unsigned char * D.21035;
  unsigned char D.21036;
  int D.21037;
  const unsigned char * D.21038;
  unsigned char D.21039;
  int D.21040;
  int D.19698;
  int iftmp.8;
  int D.19697;
  const char[5] * D.21049;
  unsigned char D.21050;
  int D.21051;
  unsigned char D.21052;
  int D.21053;
  _Bool D.21054;
  _Bool D.21055;
  _Bool D.21056;
  const unsigned char * D.21059;
  unsigned char D.21060;
  int D.21061;
  const unsigned char * D.21062;
  unsigned char D.21063;
  int D.21064;
  _Bool D.21065;
  _Bool D.21066;
  const unsigned char * D.21069;
  unsigned char D.21070;
  int D.21071;
  const unsigned char * D.21072;
  unsigned char D.21073;
  int D.21074;
  _Bool D.21075;
  _Bool D.21076;
  const unsigned char * D.21079;
  unsigned char D.21080;
  int D.21081;
  const unsigned char * D.21082;
  unsigned char D.21083;
  int D.21084;
  char * p;

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

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

      __s2 = p;
      D.20795 = "/mono";
      D.20796 = MEM[(const unsigned char *)D.20795];
      D.20797 = (int) D.20796;
      D.20798 = *__s2;
      D.20799 = (int) D.20798;
      __result = D.20797 - D.20799;
      {
        D.20800 = __s2_len != 0;
        D.20801 = __result == 0;
        D.20802 = D.20800 & D.20801;
        if (D.20802 != 0) goto <D.20803>; else goto <D.20804>;
        <D.20803>:
        D.20805 = &MEM[(void *)"/mono" + 1B];
        D.20806 = *D.20805;
        D.20807 = (int) D.20806;
        D.20808 = __s2 + 1;
        D.20809 = *D.20808;
        D.20810 = (int) D.20809;
        __result = D.20807 - D.20810;
        D.20811 = __s2_len > 1;
        D.20801 = __result == 0;
        D.20812 = D.20811 & D.20801;
        if (D.20812 != 0) goto <D.20813>; else goto <D.20814>;
        <D.20813>:
        D.20815 = &MEM[(void *)"/mono" + 2B];
        D.20816 = *D.20815;
        D.20817 = (int) D.20816;
        D.20818 = __s2 + 2;
        D.20819 = *D.20818;
        D.20820 = (int) D.20819;
        __result = D.20817 - D.20820;
        D.20821 = __s2_len > 2;
        D.20801 = __result == 0;
        D.20822 = D.20821 & D.20801;
        if (D.20822 != 0) goto <D.20823>; else goto <D.20824>;
        <D.20823>:
        D.20825 = &MEM[(void *)"/mono" + 3B];
        D.20826 = *D.20825;
        D.20827 = (int) D.20826;
        D.20828 = __s2 + 3;
        D.20829 = *D.20828;
        D.20830 = (int) D.20829;
        __result = D.20827 - D.20830;
        <D.20824>:
        <D.20814>:
        <D.20804>:
      }
      D.19643 = __result;
    }
    iftmp.2 = -D.19643;
    goto <D.20831>;
    <D.20794>:
    iftmp.2 = __builtin_strcmp (p, "/mono");
    <D.20831>:
    D.19644 = iftmp.2;
  }
  if (D.19644 != 0) goto <D.20832>; else goto <D.20833>;
  <D.20832>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.20837 = "/mono-sgen";
      D.20838 = MEM[(const unsigned char *)D.20837];
      D.20839 = (int) D.20838;
      D.20840 = *__s2;
      D.20841 = (int) D.20840;
      __result = D.20839 - D.20841;
      {
        D.20842 = __s2_len != 0;
        D.20843 = __result == 0;
        D.20844 = D.20842 & D.20843;
        if (D.20844 != 0) goto <D.20845>; else goto <D.20846>;
        <D.20845>:
        D.20847 = &MEM[(void *)"/mono-sgen" + 1B];
        D.20848 = *D.20847;
        D.20849 = (int) D.20848;
        D.20850 = __s2 + 1;
        D.20851 = *D.20850;
        D.20852 = (int) D.20851;
        __result = D.20849 - D.20852;
        D.20853 = __s2_len > 1;
        D.20843 = __result == 0;
        D.20854 = D.20853 & D.20843;
        if (D.20854 != 0) goto <D.20855>; else goto <D.20856>;
        <D.20855>:
        D.20857 = &MEM[(void *)"/mono-sgen" + 2B];
        D.20858 = *D.20857;
        D.20859 = (int) D.20858;
        D.20860 = __s2 + 2;
        D.20861 = *D.20860;
        D.20862 = (int) D.20861;
        __result = D.20859 - D.20862;
        D.20863 = __s2_len > 2;
        D.20843 = __result == 0;
        D.20864 = D.20863 & D.20843;
        if (D.20864 != 0) goto <D.20865>; else goto <D.20866>;
        <D.20865>:
        D.20867 = &MEM[(void *)"/mono-sgen" + 3B];
        D.20868 = *D.20867;
        D.20869 = (int) D.20868;
        D.20870 = __s2 + 3;
        D.20871 = *D.20870;
        D.20872 = (int) D.20871;
        __result = D.20869 - D.20872;
        <D.20866>:
        <D.20856>:
        <D.20846>:
      }
      D.19652 = __result;
    }
    iftmp.3 = -D.19652;
    goto <D.20873>;
    <D.20836>:
    iftmp.3 = __builtin_strcmp (p, "/mono-sgen");
    <D.20873>:
    D.19653 = iftmp.3;
  }
  if (D.19653 != 0) goto <D.20874>; else goto <D.20875>;
  <D.20874>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.20879 = "/pedump";
      D.20880 = MEM[(const unsigned char *)D.20879];
      D.20881 = (int) D.20880;
      D.20882 = *__s2;
      D.20883 = (int) D.20882;
      __result = D.20881 - D.20883;
      {
        D.20884 = __s2_len != 0;
        D.20885 = __result == 0;
        D.20886 = D.20884 & D.20885;
        if (D.20886 != 0) goto <D.20887>; else goto <D.20888>;
        <D.20887>:
        D.20889 = &MEM[(void *)"/pedump" + 1B];
        D.20890 = *D.20889;
        D.20891 = (int) D.20890;
        D.20892 = __s2 + 1;
        D.20893 = *D.20892;
        D.20894 = (int) D.20893;
        __result = D.20891 - D.20894;
        D.20895 = __s2_len > 1;
        D.20885 = __result == 0;
        D.20896 = D.20895 & D.20885;
        if (D.20896 != 0) goto <D.20897>; else goto <D.20898>;
        <D.20897>:
        D.20899 = &MEM[(void *)"/pedump" + 2B];
        D.20900 = *D.20899;
        D.20901 = (int) D.20900;
        D.20902 = __s2 + 2;
        D.20903 = *D.20902;
        D.20904 = (int) D.20903;
        __result = D.20901 - D.20904;
        D.20905 = __s2_len > 2;
        D.20885 = __result == 0;
        D.20906 = D.20905 & D.20885;
        if (D.20906 != 0) goto <D.20907>; else goto <D.20908>;
        <D.20907>:
        D.20909 = &MEM[(void *)"/pedump" + 3B];
        D.20910 = *D.20909;
        D.20911 = (int) D.20910;
        D.20912 = __s2 + 3;
        D.20913 = *D.20912;
        D.20914 = (int) D.20913;
        __result = D.20911 - D.20914;
        <D.20908>:
        <D.20898>:
        <D.20888>:
      }
      D.19661 = __result;
    }
    iftmp.4 = -D.19661;
    goto <D.20915>;
    <D.20878>:
    iftmp.4 = __builtin_strcmp (p, "/pedump");
    <D.20915>:
    D.19662 = iftmp.4;
  }
  if (D.19662 != 0) goto <D.20916>; else goto <D.20917>;
  <D.20916>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.20921 = "/monodis";
      D.20922 = MEM[(const unsigned char *)D.20921];
      D.20923 = (int) D.20922;
      D.20924 = *__s2;
      D.20925 = (int) D.20924;
      __result = D.20923 - D.20925;
      {
        D.20926 = __s2_len != 0;
        D.20927 = __result == 0;
        D.20928 = D.20926 & D.20927;
        if (D.20928 != 0) goto <D.20929>; else goto <D.20930>;
        <D.20929>:
        D.20931 = &MEM[(void *)"/monodis" + 1B];
        D.20932 = *D.20931;
        D.20933 = (int) D.20932;
        D.20934 = __s2 + 1;
        D.20935 = *D.20934;
        D.20936 = (int) D.20935;
        __result = D.20933 - D.20936;
        D.20937 = __s2_len > 1;
        D.20927 = __result == 0;
        D.20938 = D.20937 & D.20927;
        if (D.20938 != 0) goto <D.20939>; else goto <D.20940>;
        <D.20939>:
        D.20941 = &MEM[(void *)"/monodis" + 2B];
        D.20942 = *D.20941;
        D.20943 = (int) D.20942;
        D.20944 = __s2 + 2;
        D.20945 = *D.20944;
        D.20946 = (int) D.20945;
        __result = D.20943 - D.20946;
        D.20947 = __s2_len > 2;
        D.20927 = __result == 0;
        D.20948 = D.20947 & D.20927;
        if (D.20948 != 0) goto <D.20949>; else goto <D.20950>;
        <D.20949>:
        D.20951 = &MEM[(void *)"/monodis" + 3B];
        D.20952 = *D.20951;
        D.20953 = (int) D.20952;
        D.20954 = __s2 + 3;
        D.20955 = *D.20954;
        D.20956 = (int) D.20955;
        __result = D.20953 - D.20956;
        <D.20950>:
        <D.20940>:
        <D.20930>:
      }
      D.19670 = __result;
    }
    iftmp.5 = -D.19670;
    goto <D.20957>;
    <D.20920>:
    iftmp.5 = __builtin_strcmp (p, "/monodis");
    <D.20957>:
    D.19671 = iftmp.5;
  }
  if (D.19671 != 0) goto <D.20958>; else goto <D.20959>;
  <D.20958>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.20963 = "/mint";
      D.20964 = MEM[(const unsigned char *)D.20963];
      D.20965 = (int) D.20964;
      D.20966 = *__s2;
      D.20967 = (int) D.20966;
      __result = D.20965 - D.20967;
      {
        D.20968 = __s2_len != 0;
        D.20969 = __result == 0;
        D.20970 = D.20968 & D.20969;
        if (D.20970 != 0) goto <D.20971>; else goto <D.20972>;
        <D.20971>:
        D.20973 = &MEM[(void *)"/mint" + 1B];
        D.20974 = *D.20973;
        D.20975 = (int) D.20974;
        D.20976 = __s2 + 1;
        D.20977 = *D.20976;
        D.20978 = (int) D.20977;
        __result = D.20975 - D.20978;
        D.20979 = __s2_len > 1;
        D.20969 = __result == 0;
        D.20980 = D.20979 & D.20969;
        if (D.20980 != 0) goto <D.20981>; else goto <D.20982>;
        <D.20981>:
        D.20983 = &MEM[(void *)"/mint" + 2B];
        D.20984 = *D.20983;
        D.20985 = (int) D.20984;
        D.20986 = __s2 + 2;
        D.20987 = *D.20986;
        D.20988 = (int) D.20987;
        __result = D.20985 - D.20988;
        D.20989 = __s2_len > 2;
        D.20969 = __result == 0;
        D.20990 = D.20989 & D.20969;
        if (D.20990 != 0) goto <D.20991>; else goto <D.20992>;
        <D.20991>:
        D.20993 = &MEM[(void *)"/mint" + 3B];
        D.20994 = *D.20993;
        D.20995 = (int) D.20994;
        D.20996 = __s2 + 3;
        D.20997 = *D.20996;
        D.20998 = (int) D.20997;
        __result = D.20995 - D.20998;
        <D.20992>:
        <D.20982>:
        <D.20972>:
      }
      D.19679 = __result;
    }
    iftmp.6 = -D.19679;
    goto <D.20999>;
    <D.20962>:
    iftmp.6 = __builtin_strcmp (p, "/mint");
    <D.20999>:
    D.19680 = iftmp.6;
  }
  if (D.19680 != 0) goto <D.21000>; else goto <D.21001>;
  <D.21000>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.21005 = "/monodiet";
      D.21006 = MEM[(const unsigned char *)D.21005];
      D.21007 = (int) D.21006;
      D.21008 = *__s2;
      D.21009 = (int) D.21008;
      __result = D.21007 - D.21009;
      {
        D.21010 = __s2_len != 0;
        D.21011 = __result == 0;
        D.21012 = D.21010 & D.21011;
        if (D.21012 != 0) goto <D.21013>; else goto <D.21014>;
        <D.21013>:
        D.21015 = &MEM[(void *)"/monodiet" + 1B];
        D.21016 = *D.21015;
        D.21017 = (int) D.21016;
        D.21018 = __s2 + 1;
        D.21019 = *D.21018;
        D.21020 = (int) D.21019;
        __result = D.21017 - D.21020;
        D.21021 = __s2_len > 1;
        D.21011 = __result == 0;
        D.21022 = D.21021 & D.21011;
        if (D.21022 != 0) goto <D.21023>; else goto <D.21024>;
        <D.21023>:
        D.21025 = &MEM[(void *)"/monodiet" + 2B];
        D.21026 = *D.21025;
        D.21027 = (int) D.21026;
        D.21028 = __s2 + 2;
        D.21029 = *D.21028;
        D.21030 = (int) D.21029;
        __result = D.21027 - D.21030;
        D.21031 = __s2_len > 2;
        D.21011 = __result == 0;
        D.21032 = D.21031 & D.21011;
        if (D.21032 != 0) goto <D.21033>; else goto <D.21034>;
        <D.21033>:
        D.21035 = &MEM[(void *)"/monodiet" + 3B];
        D.21036 = *D.21035;
        D.21037 = (int) D.21036;
        D.21038 = __s2 + 3;
        D.21039 = *D.21038;
        D.21040 = (int) D.21039;
        __result = D.21037 - D.21040;
        <D.21034>:
        <D.21024>:
        <D.21014>:
      }
      D.19688 = __result;
    }
    iftmp.7 = -D.19688;
    goto <D.21041>;
    <D.21004>:
    iftmp.7 = __builtin_strcmp (p, "/monodiet");
    <D.21041>:
    D.19689 = iftmp.7;
  }
  if (D.19689 != 0) goto <D.21042>; else goto <D.21043>;
  <D.21042>:
  D.20791 = 0B;
  return D.20791;
  <D.21043>:
  <D.21001>:
  <D.20959>:
  <D.20917>:
  <D.20875>:
  <D.20833>:
  *p = 0;
  p = strrchr (path, 47);
  if (p == 0B) goto <D.21044>; else goto <D.21045>;
  <D.21044>:
  D.20791 = 0B;
  return D.20791;
  <D.21045>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.21049 = "/bin";
      D.21050 = MEM[(const unsigned char *)D.21049];
      D.21051 = (int) D.21050;
      D.21052 = *__s2;
      D.21053 = (int) D.21052;
      __result = D.21051 - D.21053;
      {
        D.21054 = __s2_len != 0;
        D.21055 = __result == 0;
        D.21056 = D.21054 & D.21055;
        if (D.21056 != 0) goto <D.21057>; else goto <D.21058>;
        <D.21057>:
        D.21059 = &MEM[(void *)"/bin" + 1B];
        D.21060 = *D.21059;
        D.21061 = (int) D.21060;
        D.21062 = __s2 + 1;
        D.21063 = *D.21062;
        D.21064 = (int) D.21063;
        __result = D.21061 - D.21064;
        D.21065 = __s2_len > 1;
        D.21055 = __result == 0;
        D.21066 = D.21065 & D.21055;
        if (D.21066 != 0) goto <D.21067>; else goto <D.21068>;
        <D.21067>:
        D.21069 = &MEM[(void *)"/bin" + 2B];
        D.21070 = *D.21069;
        D.21071 = (int) D.21070;
        D.21072 = __s2 + 2;
        D.21073 = *D.21072;
        D.21074 = (int) D.21073;
        __result = D.21071 - D.21074;
        D.21075 = __s2_len > 2;
        D.21055 = __result == 0;
        D.21076 = D.21075 & D.21055;
        if (D.21076 != 0) goto <D.21077>; else goto <D.21078>;
        <D.21077>:
        D.21079 = &MEM[(void *)"/bin" + 3B];
        D.21080 = *D.21079;
        D.21081 = (int) D.21080;
        D.21082 = __s2 + 3;
        D.21083 = *D.21082;
        D.21084 = (int) D.21083;
        __result = D.21081 - D.21084;
        <D.21078>:
        <D.21068>:
        <D.21058>:
      }
      D.19697 = __result;
    }
    iftmp.8 = -D.19697;
    goto <D.21085>;
    <D.21048>:
    iftmp.8 = __builtin_strcmp (p, "/bin");
    <D.21085>:
    D.19698 = iftmp.8;
  }
  if (D.19698 != 0) goto <D.21086>; else goto <D.21087>;
  <D.21086>:
  D.20791 = 0B;
  return D.20791;
  <D.21087>:
  *p = 0;
  D.20791 = path;
  return D.20791;
}


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

  D.21089 = __xstat (3, __path, __statbuf);
  return D.21089;
}


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


mono_assemblies_init ()
{
  const char * D.21091;

  D.21091 = mono_assembly_getrootdir ();
  if (D.21091 == 0B) goto <D.21092>; else goto <D.21093>;
  <D.21092>:
  mono_set_rootdir ();
  <D.21093>:
  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.21094>; else goto <D.21096>;
  <D.21096>:
  assemblies_path.9 = assemblies_path;
  if (assemblies_path.9 != 0B) goto <D.21094>; else goto <D.21095>;
  <D.21094>:
  return;
  <D.21095>:
  mono_set_assemblies_path (path);
}


check_extra_gac_path_env ()
{
  char * * extra_gac_paths.10;
  char * D.21104;
  char D.21105;
  char * * dest.11;
  const gchar * D.21109;
  int D.21114;
  const char * path;
  char * * splitted;
  char * * dest;

  path = monoeg_g_getenv ("MONO_GAC_PREFIX");
  if (path == 0B) goto <D.21099>; else goto <D.21100>;
  <D.21099>:
  return;
  <D.21100>:
  splitted = monoeg_g_strsplit (path, ":", 1000);
  extra_gac_paths.10 = extra_gac_paths;
  if (extra_gac_paths.10 != 0B) goto <D.21102>; else goto <D.21103>;
  <D.21102>:
  extra_gac_paths.10 = extra_gac_paths;
  monoeg_g_strfreev (extra_gac_paths.10);
  <D.21103>:
  dest = splitted;
  extra_gac_paths = dest;
  goto <D.19540>;
  <D.19539>:
  D.21104 = *splitted;
  D.21105 = *D.21104;
  if (D.21105 != 0) goto <D.21106>; else goto <D.21107>;
  <D.21106>:
  dest.11 = dest;
  dest = dest.11 + 4;
  D.21104 = *splitted;
  *dest.11 = D.21104;
  <D.21107>:
  splitted = splitted + 4;
  <D.19540>:
  D.21104 = *splitted;
  if (D.21104 != 0B) goto <D.19539>; else goto <D.19541>;
  <D.19541>:
  D.21104 = *splitted;
  *dest = D.21104;
  D.21109 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.21109 == 0B) goto <D.21110>; else goto <D.21111>;
  <D.21110>:
  return;
  <D.21111>:
  goto <D.19543>;
  <D.19542>:
  D.21104 = *splitted;
  D.21105 = *D.21104;
  if (D.21105 != 0) goto <D.21112>; else goto <D.21113>;
  <D.21112>:
  D.21104 = *splitted;
  D.21114 = monoeg_g_file_test (D.21104, 4);
  if (D.21114 == 0) goto <D.21115>; else goto <D.21116>;
  <D.21115>:
  D.21104 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_GAC_PREFIX doesn\'t exist or has wrong permissions.", D.21104);
  <D.21116>:
  <D.21113>:
  splitted = splitted + 4;
  <D.19543>:
  D.21104 = *splitted;
  if (D.21104 != 0B) goto <D.19542>; else goto <D.19544>;
  <D.19544>:
}


mono_assembly_fill_assembly_name (struct MonoImage * image, struct MonoAssemblyName * aname)
{
  unsigned int D.21118;
  unsigned int D.21119;
  mono_bool D.21122;
  unsigned int D.21123;
  const char * D.21124;
  unsigned int D.21125;
  const char * D.21126;
  unsigned int D.21127;
  unsigned int D.21128;
  short unsigned int D.21129;
  unsigned int D.21130;
  short unsigned int D.21131;
  unsigned int D.21132;
  short unsigned int D.21133;
  unsigned int D.21134;
  short unsigned int D.21135;
  unsigned int D.21136;
  unsigned int D.21137;
  const char * pkey.12;
  const gchar * pkey.13;
  unsigned int D.21142;
  const mono_byte * D.21143;
  unsigned int len.14;
  mono_byte[17] * D.21145;
  const char * D.21149;
  void * D.21151;
  short unsigned int D.21152;
  unsigned int D.21153;
  int D.21154;
  int D.21158;
  struct MonoTableInfo * t;
  guint32 cols[9];
  gint32 machine;
  gint32 flags;

  try
    {
      t = &image->tables[32];
      D.21118 = BIT_FIELD_REF <*t, 32, 32>;
      D.21119 = D.21118 & 16777215;
      if (D.21119 == 0) goto <D.21120>; else goto <D.21121>;
      <D.21120>:
      D.21122 = 0;
      return D.21122;
      <D.21121>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      aname->hash_len = 0;
      aname->hash_value = 0B;
      D.21123 = cols[7];
      D.21124 = mono_metadata_string_heap (image, D.21123);
      aname->name = D.21124;
      D.21125 = cols[8];
      D.21126 = mono_metadata_string_heap (image, D.21125);
      aname->culture = D.21126;
      D.21127 = cols[5];
      aname->flags = D.21127;
      D.21128 = cols[1];
      D.21129 = (short unsigned int) D.21128;
      aname->major = D.21129;
      D.21130 = cols[2];
      D.21131 = (short unsigned int) D.21130;
      aname->minor = D.21131;
      D.21132 = cols[3];
      D.21133 = (short unsigned int) D.21132;
      aname->build = D.21133;
      D.21134 = cols[4];
      D.21135 = (short unsigned int) D.21134;
      aname->revision = D.21135;
      D.21136 = cols[0];
      aname->hash_alg = D.21136;
      D.21137 = cols[6];
      if (D.21137 != 0) goto <D.21138>; else goto <D.21139>;
      <D.21138>:
      {
        guchar * token;
        gchar * encoded;
        const gchar * pkey;
        int len;

        try
          {
            token = monoeg_malloc (8);
            D.21137 = cols[6];
            pkey.12 = mono_metadata_blob_heap (image, D.21137);
            pkey = pkey.12;
            pkey.13 = pkey;
            D.21142 = mono_metadata_decode_blob_size (pkey.13, &pkey);
            len = (int) D.21142;
            pkey.13 = pkey;
            aname->public_key = pkey.13;
            D.21143 = aname->public_key;
            len.14 = (unsigned int) len;
            mono_digest_get_public_token (token, D.21143, len.14);
            encoded = encode_public_tok (token, 8);
            D.21145 = &aname->public_key_token;
            monoeg_g_strlcpy (D.21145, encoded, 17);
            monoeg_g_free (encoded);
            monoeg_g_free (token);
          }
        finally
          {
            pkey = {CLOBBER};
          }
      }
      goto <D.21146>;
      <D.21139>:
      aname->public_key = 0B;
      D.21145 = &aname->public_key_token;
      memset (D.21145, 0, 17);
      <D.21146>:
      D.21137 = cols[6];
      if (D.21137 != 0) goto <D.21147>; else goto <D.21148>;
      <D.21147>:
      D.21137 = cols[6];
      D.21149 = mono_metadata_blob_heap (image, D.21137);
      aname->public_key = D.21149;
      goto <D.21150>;
      <D.21148>:
      aname->public_key = 0B;
      <D.21150>:
      D.21151 = image->image_info;
      D.21152 = MEM[(struct MonoCLIImageInfo *)D.21151].cli_header.coff.coff_machine;
      machine = (gint32) D.21152;
      D.21151 = image->image_info;
      D.21153 = MEM[(struct MonoCLIImageInfo *)D.21151].cli_cli_header.ch_flags;
      flags = (gint32) D.21153;
      switch (machine) <default: <D.19751>, case 332: <D.19746>, case 452: <D.19750>, case 512: <D.19748>, case 34404: <D.19749>>
      <D.19746>:
      D.21154 = flags & 18;
      if (D.21154 != 0) goto <D.21155>; else goto <D.21156>;
      <D.21155>:
      aname->arch = 2;
      goto <D.21157>;
      <D.21156>:
      D.21158 = flags & 112;
      if (D.21158 == 112) goto <D.21159>; else goto <D.21160>;
      <D.21159>:
      aname->arch = 0;
      goto <D.21161>;
      <D.21160>:
      aname->arch = 1;
      <D.21161>:
      <D.21157>:
      goto <D.19747>;
      <D.19748>:
      aname->arch = 3;
      goto <D.19747>;
      <D.19749>:
      aname->arch = 4;
      goto <D.19747>;
      <D.19750>:
      aname->arch = 5;
      goto <D.19747>;
      <D.19751>:
      goto <D.19747>;
      <D.19747>:
      D.21122 = 1;
      return D.21122;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


encode_public_tok (const guchar * token, gint32 len)
{
  int D.21165;
  int D.21166;
  unsigned int D.21167;
  int D.21168;
  sizetype D.21169;
  gchar * D.21170;
  sizetype i.15;
  const guchar * D.21172;
  unsigned char D.21173;
  unsigned char D.21174;
  int D.21175;
  char D.21176;
  sizetype D.21177;
  gchar * D.21178;
  int D.21179;
  int D.21180;
  char D.21181;
  sizetype D.21182;
  gchar * D.21183;
  gchar * D.21184;
  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.21165 = len * 2;
  D.21166 = D.21165 + 1;
  D.21167 = (unsigned int) D.21166;
  res = monoeg_malloc (D.21167);
  i = 0;
  goto <D.19512>;
  <D.19511>:
  D.21168 = i * 2;
  D.21169 = (sizetype) D.21168;
  D.21170 = res + D.21169;
  i.15 = (sizetype) i;
  D.21172 = token + i.15;
  D.21173 = *D.21172;
  D.21174 = D.21173 >> 4;
  D.21175 = (int) D.21174;
  D.21176 = allowed[D.21175];
  *D.21170 = D.21176;
  D.21168 = i * 2;
  D.21169 = (sizetype) D.21168;
  D.21177 = D.21169 + 1;
  D.21178 = res + D.21177;
  i.15 = (sizetype) i;
  D.21172 = token + i.15;
  D.21173 = *D.21172;
  D.21179 = (int) D.21173;
  D.21180 = D.21179 & 15;
  D.21181 = allowed[D.21180];
  *D.21178 = D.21181;
  i = i + 1;
  <D.19512>:
  if (i < len) goto <D.19511>; else goto <D.19513>;
  <D.19513>:
  D.21165 = len * 2;
  D.21182 = (sizetype) D.21165;
  D.21183 = res + D.21182;
  *D.21183 = 0;
  D.21184 = res;
  return D.21184;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21188;
  int D.21193;
  void * D.21195;
  unsigned int D.21196;

  D.21188 = __builtin_constant_p (__len);
  if (D.21188 != 0) goto <D.21189>; else goto <D.21190>;
  <D.21189>:
  if (__len == 0) goto <D.21191>; else goto <D.21192>;
  <D.21191>:
  D.21193 = __builtin_constant_p (__ch);
  if (D.21193 == 0) goto <D.21186>; else goto <D.21194>;
  <D.21194>:
  if (__ch != 0) goto <D.21186>; else goto <D.21187>;
  <D.21186>:
  __warn_memset_zero_len ();
  D.21195 = __dest;
  return D.21195;
  <D.21187>:
  <D.21192>:
  <D.21190>:
  D.21196 = __builtin_object_size (__dest, 0);
  D.21195 = __builtin___memset_chk (__dest, __ch, __len, D.21196);
  return D.21195;
}


mono_stringify_assembly_name (struct MonoAssemblyName * aname)
{
  const char * iftmp.16;
  const char * D.21201;
  const short unsigned int * * D.21203;
  const short unsigned int * D.21204;
  char D.21205;
  unsigned int D.21206;
  unsigned int D.21207;
  const short unsigned int * D.21208;
  short unsigned int D.21209;
  int D.21210;
  int D.21211;
  char * D.21213;
  short unsigned int D.21214;
  int D.21215;
  short unsigned int D.21216;
  int D.21217;
  short unsigned int D.21218;
  int D.21219;
  short unsigned int D.21220;
  int D.21221;
  const char * iftmp.17;
  const char * D.21225;
  char D.21227;
  const char * iftmp.18;
  unsigned char D.21230;
  const char * iftmp.19;
  unsigned int D.21235;
  unsigned int D.21236;
  const char * quote;

  D.21201 = aname->name;
  if (D.21201 != 0B) goto <D.21202>; else goto <D.21199>;
  <D.21202>:
  D.21203 = __ctype_b_loc ();
  D.21204 = *D.21203;
  D.21201 = aname->name;
  D.21205 = *D.21201;
  D.21206 = (unsigned int) D.21205;
  D.21207 = D.21206 * 2;
  D.21208 = D.21204 + D.21207;
  D.21209 = *D.21208;
  D.21210 = (int) D.21209;
  D.21211 = D.21210 & 8192;
  if (D.21211 != 0) goto <D.21212>; else goto <D.21199>;
  <D.21212>:
  iftmp.16 = "\"";
  goto <D.21200>;
  <D.21199>:
  iftmp.16 = "";
  <D.21200>:
  quote = iftmp.16;
  D.21201 = aname->name;
  D.21214 = aname->major;
  D.21215 = (int) D.21214;
  D.21216 = aname->minor;
  D.21217 = (int) D.21216;
  D.21218 = aname->build;
  D.21219 = (int) D.21218;
  D.21220 = aname->revision;
  D.21221 = (int) D.21220;
  D.21225 = aname->culture;
  if (D.21225 != 0B) goto <D.21226>; else goto <D.21223>;
  <D.21226>:
  D.21225 = aname->culture;
  D.21227 = *D.21225;
  if (D.21227 != 0) goto <D.21228>; else goto <D.21223>;
  <D.21228>:
  iftmp.17 = aname->culture;
  goto <D.21224>;
  <D.21223>:
  iftmp.17 = "neutral";
  <D.21224>:
  D.21230 = aname->public_key_token[0];
  if (D.21230 != 0) goto <D.21231>; else goto <D.21232>;
  <D.21231>:
  iftmp.18 = &aname->public_key_token;
  goto <D.21233>;
  <D.21232>:
  iftmp.18 = "null";
  <D.21233>:
  D.21235 = aname->flags;
  D.21236 = D.21235 & 256;
  if (D.21236 != 0) goto <D.21237>; else goto <D.21238>;
  <D.21237>:
  iftmp.19 = ", Retargetable=Yes";
  goto <D.21239>;
  <D.21238>:
  iftmp.19 = "";
  <D.21239>:
  D.21213 = monoeg_g_strdup_printf ("%s%s%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", quote, D.21201, quote, D.21215, D.21217, D.21219, D.21221, iftmp.17, iftmp.18, iftmp.19);
  return D.21213;
}


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

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.21242;
  unsigned int D.21243;

  D.21243 = __sync_add_and_fetch_4 (val, 1);
  D.21242 = (gint32) D.21243;
  return D.21242;
}


mono_assembly_get_assemblyref (struct MonoImage * image, int index, struct MonoAssemblyName * aname)
{
  unsigned int D.21245;
  const char * hash.20;
  const char * hash.21;
  unsigned int D.21248;
  unsigned int D.21249;
  const char * D.21250;
  unsigned int D.21251;
  const char * D.21252;
  unsigned int D.21253;
  unsigned int D.21254;
  short unsigned int D.21255;
  unsigned int D.21256;
  short unsigned int D.21257;
  unsigned int D.21258;
  short unsigned int D.21259;
  unsigned int D.21260;
  short unsigned int D.21261;
  unsigned int D.21262;
  unsigned int D.21265;
  mono_byte[17] * D.21266;
  struct MonoTableInfo * t;
  guint32 cols[9];
  const char * hash;

  try
    {
      t = &image->tables[35];
      mono_metadata_decode_row (t, index, &cols, 9);
      D.21245 = cols[8];
      hash.20 = mono_metadata_blob_heap (image, D.21245);
      hash = hash.20;
      hash.21 = hash;
      D.21248 = mono_metadata_decode_blob_size (hash.21, &hash);
      aname->hash_len = D.21248;
      hash.21 = hash;
      aname->hash_value = hash.21;
      D.21249 = cols[6];
      D.21250 = mono_metadata_string_heap (image, D.21249);
      aname->name = D.21250;
      D.21251 = cols[7];
      D.21252 = mono_metadata_string_heap (image, D.21251);
      aname->culture = D.21252;
      D.21253 = cols[4];
      aname->flags = D.21253;
      D.21254 = cols[0];
      D.21255 = (short unsigned int) D.21254;
      aname->major = D.21255;
      D.21256 = cols[1];
      D.21257 = (short unsigned int) D.21256;
      aname->minor = D.21257;
      D.21258 = cols[2];
      D.21259 = (short unsigned int) D.21258;
      aname->build = D.21259;
      D.21260 = cols[3];
      D.21261 = (short unsigned int) D.21260;
      aname->revision = D.21261;
      D.21262 = cols[5];
      if (D.21262 != 0) goto <D.21263>; else goto <D.21264>;
      <D.21263>:
      {
        gchar * token;

        D.21262 = cols[5];
        D.21265 = aname->flags;
        token = assemblyref_public_tok (image, D.21262, D.21265);
        D.21266 = &aname->public_key_token;
        monoeg_g_strlcpy (D.21266, token, 17);
        monoeg_g_free (token);
      }
      goto <D.21267>;
      <D.21264>:
      D.21266 = &aname->public_key_token;
      memset (D.21266, 0, 17);
      <D.21267>:
    }
  finally
    {
      cols = {CLOBBER};
      hash = {CLOBBER};
    }
}


assemblyref_public_tok (struct MonoImage * image, guint32 key_index, guint32 flags)
{
  const char * public_tok.22;
  const gchar * public_tok.23;
  unsigned int D.21270;
  unsigned int D.21271;
  unsigned int len.24;
  gchar * D.21275;
  const gchar * public_tok;
  int len;

  try
    {
      public_tok.22 = mono_metadata_blob_heap (image, key_index);
      public_tok = public_tok.22;
      public_tok.23 = public_tok;
      D.21270 = mono_metadata_decode_blob_size (public_tok.23, &public_tok);
      len = (int) D.21270;
      D.21271 = flags & 1;
      if (D.21271 != 0) goto <D.21272>; else goto <D.21273>;
      <D.21272>:
      {
        guchar token[8];

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


mono_assembly_load_reference (struct MonoImage * image, int index)
{
  _Bool D.21281;
  long int D.21282;
  long int D.21283;
  struct MonoAssembly * * D.21286;
  <unnamed-unsigned:24> D.21289;
  int D.21290;
  int D.21291;
  unsigned int D.21292;
  unsigned int D.21293;
  void * D.21294;
  unsigned int index.25;
  unsigned int D.21296;
  struct MonoAssembly * * D.21297;
  _Bool D.21300;
  long int D.21301;
  long int D.21302;
  struct MonoAssembly * D.21309;
  int D.21311;
  int D.19851;
  int iftmp.26;
  int D.19850;
  const char[9] * D.21316;
  unsigned char D.21317;
  int D.21318;
  unsigned char D.21319;
  int D.21320;
  _Bool D.21321;
  _Bool D.21322;
  _Bool D.21323;
  const unsigned char * D.21326;
  unsigned char D.21327;
  int D.21328;
  const unsigned char * D.21329;
  unsigned char D.21330;
  int D.21331;
  _Bool D.21332;
  _Bool D.21333;
  const unsigned char * D.21336;
  unsigned char D.21337;
  int D.21338;
  const unsigned char * D.21339;
  unsigned char D.21340;
  int D.21341;
  _Bool D.21342;
  _Bool D.21343;
  const unsigned char * D.21346;
  unsigned char D.21347;
  int D.21348;
  const unsigned char * D.21349;
  unsigned char D.21350;
  int D.21351;
  const char * D.21353;
  char * D.21356;
  const char * iftmp.27;
  <unnamed type> status.28;
  int * D.21372;
  int D.21373;
  const char * iftmp.29;
  char * D.21381;
  char * D.21389;
  short unsigned int D.21390;
  int D.21391;
  short unsigned int D.21392;
  int D.21393;
  short unsigned int D.21394;
  int D.21395;
  short unsigned int D.21396;
  int D.21397;
  const char * iftmp.30;
  mono_byte[17] * D.21399;
  char D.21400;
  _Bool D.21406;
  long int D.21407;
  long int D.21408;
  struct MonoAssembly * D.21413;
  const char * D.21420;
  const char * D.21421;
  int D.21422;
  _Bool D.21428;
  long int D.21429;
  long int D.21430;
  struct MonoAssembly * reference;
  struct MonoAssemblyName aname;
  MonoImageOpenStatus status;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.21279>; else goto <D.21280>;
        <D.21279>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.21280>:
        D.21281 = ret != 0;
        D.21282 = (long int) D.21281;
        D.21283 = __builtin_expect (D.21282, 0);
        if (D.21283 != 0) goto <D.21284>; else goto <D.21285>;
        <D.21284>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1074, "ret == 0");
        <D.21285>:
      }
      D.21286 = image->references;
      if (D.21286 == 0B) goto <D.21287>; else goto <D.21288>;
      <D.21287>:
      {
        struct MonoTableInfo * t;

        t = &image->tables[35];
        D.21289 = t->rows;
        D.21290 = (int) D.21289;
        D.21291 = D.21290 + 1;
        D.21292 = (unsigned int) D.21291;
        D.21293 = D.21292 * 4;
        D.21294 = monoeg_malloc0 (D.21293);
        image->references = D.21294;
        D.21289 = t->rows;
        D.21290 = (int) D.21289;
        image->nreferences = D.21290;
      }
      <D.21288>:
      D.21286 = image->references;
      index.25 = (unsigned int) index;
      D.21296 = index.25 * 4;
      D.21297 = D.21286 + D.21296;
      reference = *D.21297;
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.21298>; else goto <D.21299>;
        <D.21298>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21299>:
        D.21300 = ret != 0;
        D.21301 = (long int) D.21300;
        D.21302 = __builtin_expect (D.21301, 0);
        if (D.21302 != 0) goto <D.21303>; else goto <D.21304>;
        <D.21303>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1082, "ret == 0");
        <D.21304>:
      }
      if (reference != 0B) goto <D.21305>; else goto <D.21306>;
      <D.21305>:
      return;
      <D.21306>:
      mono_assembly_get_assemblyref (image, index, &aname);
      D.21309 = image->assembly;
      if (D.21309 != 0B) goto <D.21310>; else goto <D.21307>;
      <D.21310>:
      D.21309 = image->assembly;
      D.21311 = D.21309->ref_only;
      if (D.21311 != 0) goto <D.21312>; else goto <D.21307>;
      <D.21312>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = aname.name;
          D.21316 = "mscorlib";
          D.21317 = MEM[(const unsigned char *)D.21316];
          D.21318 = (int) D.21317;
          D.21319 = *__s2;
          D.21320 = (int) D.21319;
          __result = D.21318 - D.21320;
          {
            D.21321 = __s2_len != 0;
            D.21322 = __result == 0;
            D.21323 = D.21321 & D.21322;
            if (D.21323 != 0) goto <D.21324>; else goto <D.21325>;
            <D.21324>:
            D.21326 = &MEM[(void *)"mscorlib" + 1B];
            D.21327 = *D.21326;
            D.21328 = (int) D.21327;
            D.21329 = __s2 + 1;
            D.21330 = *D.21329;
            D.21331 = (int) D.21330;
            __result = D.21328 - D.21331;
            D.21332 = __s2_len > 1;
            D.21322 = __result == 0;
            D.21333 = D.21332 & D.21322;
            if (D.21333 != 0) goto <D.21334>; else goto <D.21335>;
            <D.21334>:
            D.21336 = &MEM[(void *)"mscorlib" + 2B];
            D.21337 = *D.21336;
            D.21338 = (int) D.21337;
            D.21339 = __s2 + 2;
            D.21340 = *D.21339;
            D.21341 = (int) D.21340;
            __result = D.21338 - D.21341;
            D.21342 = __s2_len > 2;
            D.21322 = __result == 0;
            D.21343 = D.21342 & D.21322;
            if (D.21343 != 0) goto <D.21344>; else goto <D.21345>;
            <D.21344>:
            D.21346 = &MEM[(void *)"mscorlib" + 3B];
            D.21347 = *D.21346;
            D.21348 = (int) D.21347;
            D.21349 = __s2 + 3;
            D.21350 = *D.21349;
            D.21351 = (int) D.21350;
            __result = D.21348 - D.21351;
            <D.21345>:
            <D.21335>:
            <D.21325>:
          }
          D.19850 = __result;
        }
        iftmp.26 = -D.19850;
        goto <D.21352>;
        <D.21315>:
        D.21353 = aname.name;
        iftmp.26 = __builtin_strcmp (D.21353, "mscorlib");
        <D.21352>:
        D.19851 = iftmp.26;
      }
      if (D.19851 == 0) goto <D.21354>; else goto <D.21355>;
      <D.21354>:
      D.21309 = image->assembly;
      D.21356 = D.21309->basedir;
      reference = mono_assembly_load_full (&aname, D.21356, &status, 0);
      goto <D.21357>;
      <D.21355>:
      reference = mono_assembly_loaded_full (&aname, 1);
      if (reference == 0B) goto <D.21358>; else goto <D.21359>;
      <D.21358>:
      reference = mono_assembly_invoke_search_hook_internal (&aname, 1, 1);
      <D.21359>:
      <D.21357>:
      if (reference == 0B) goto <D.21360>; else goto <D.21361>;
      <D.21360>:
      reference = 4294967295B;
      <D.21361>:
      goto <D.21308>;
      <D.21307>:
      D.21309 = image->assembly;
      if (D.21309 != 0B) goto <D.21363>; else goto <D.21364>;
      <D.21363>:
      D.21309 = image->assembly;
      iftmp.27 = D.21309->basedir;
      goto <D.21365>;
      <D.21364>:
      iftmp.27 = 0B;
      <D.21365>:
      reference = mono_assembly_load (&aname, iftmp.27, &status);
      <D.21308>:
      if (reference == 0B) goto <D.21366>; else goto <D.21367>;
      <D.21366>:
      {
        char * extra_msg;

        status.28 = status;
        if (status.28 == 1) goto <D.21371>; else goto <D.21368>;
        <D.21371>:
        D.21372 = __errno_location ();
        D.21373 = *D.21372;
        if (D.21373 == 2) goto <D.21374>; else goto <D.21368>;
        <D.21374>:
        D.21309 = image->assembly;
        if (D.21309 != 0B) goto <D.21376>; else goto <D.21377>;
        <D.21376>:
        D.21309 = image->assembly;
        iftmp.29 = D.21309->basedir;
        goto <D.21378>;
        <D.21377>:
        iftmp.29 = "";
        <D.21378>:
        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.29);
        goto <D.21369>;
        <D.21368>:
        status.28 = status;
        if (status.28 == 1) goto <D.21379>; else goto <D.21380>;
        <D.21379>:
        D.21372 = __errno_location ();
        D.21373 = *D.21372;
        D.21381 = strerror (D.21373);
        extra_msg = monoeg_g_strdup_printf ("System error: %s\n", D.21381);
        goto <D.21382>;
        <D.21380>:
        status.28 = status;
        if (status.28 == 2) goto <D.21383>; else goto <D.21384>;
        <D.21383>:
        extra_msg = monoeg_strdup ("Cannot find an assembly referenced from this one.\n");
        goto <D.21385>;
        <D.21384>:
        status.28 = status;
        if (status.28 == 3) goto <D.21386>; else goto <D.21387>;
        <D.21386>:
        extra_msg = monoeg_strdup ("The file exists but is not a valid assembly.\n");
        goto <D.21388>;
        <D.21387>:
        extra_msg = monoeg_strdup ("");
        <D.21388>:
        <D.21385>:
        <D.21382>:
        <D.21369>:
        D.21389 = image->name;
        D.21353 = aname.name;
        D.21390 = aname.major;
        D.21391 = (int) D.21390;
        D.21392 = aname.minor;
        D.21393 = (int) D.21392;
        D.21394 = aname.build;
        D.21395 = (int) D.21394;
        D.21396 = aname.revision;
        D.21397 = (int) D.21396;
        D.21399 = &aname.public_key_token;
        D.21400 = MEM[(const char *)D.21399];
        if (D.21400 != 0) goto <D.21401>; else goto <D.21402>;
        <D.21401>:
        iftmp.30 = &aname.public_key_token;
        goto <D.21403>;
        <D.21402>:
        iftmp.30 = "(none)";
        <D.21403>:
        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.21389, D.21353, index, D.21391, D.21393, D.21395, D.21397, iftmp.30, extra_msg);
        monoeg_g_free (extra_msg);
      }
      <D.21367>:
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.21404>; else goto <D.21405>;
        <D.21404>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.21405>:
        D.21406 = ret != 0;
        D.21407 = (long int) D.21406;
        D.21408 = __builtin_expect (D.21407, 0);
        if (D.21408 != 0) goto <D.21409>; else goto <D.21410>;
        <D.21409>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1133, "ret == 0");
        <D.21410>:
      }
      if (reference == 0B) goto <D.21411>; else goto <D.21412>;
      <D.21411>:
      reference = 4294967295B;
      <D.21412>:
      D.21286 = image->references;
      index.25 = (unsigned int) index;
      D.21296 = index.25 * 4;
      D.21297 = D.21286 + D.21296;
      D.21413 = *D.21297;
      if (D.21413 == 0B) goto <D.21414>; else goto <D.21415>;
      <D.21414>:
      if (reference != 4294967295B) goto <D.21416>; else goto <D.21417>;
      <D.21416>:
      mono_assembly_addref (reference);
      D.21309 = image->assembly;
      if (D.21309 != 0B) goto <D.21418>; else goto <D.21419>;
      <D.21418>:
      D.21309 = image->assembly;
      D.21420 = D.21309->aname.name;
      D.21309 = image->assembly;
      D.21421 = reference->aname.name;
      D.21422 = reference->ref_count;
      mono_trace (64, 1, "Assembly Ref addref %s[%p] -> %s[%p]: %d", D.21420, D.21309, D.21421, reference, D.21422);
      <D.21419>:
      goto <D.21423>;
      <D.21417>:
      D.21309 = image->assembly;
      if (D.21309 != 0B) goto <D.21424>; else goto <D.21425>;
      <D.21424>:
      D.21309 = image->assembly;
      D.21420 = D.21309->aname.name;
      D.21309 = image->assembly;
      mono_trace (64, 1, "Failed to load assembly %s[%p]\n", D.21420, D.21309);
      <D.21425>:
      <D.21423>:
      D.21286 = image->references;
      index.25 = (unsigned int) index;
      D.21296 = index.25 * 4;
      D.21297 = D.21286 + D.21296;
      *D.21297 = reference;
      <D.21415>:
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.21426>; else goto <D.21427>;
        <D.21426>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21427>:
        D.21428 = ret != 0;
        D.21429 = (long int) D.21428;
        D.21430 = __builtin_expect (D.21429, 0);
        if (D.21430 != 0) goto <D.21431>; else goto <D.21432>;
        <D.21431>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1153, "ret == 0");
        <D.21432>:
      }
      D.21286 = image->references;
      index.25 = (unsigned int) index;
      D.21296 = index.25 * 4;
      D.21297 = D.21286 + D.21296;
      D.21413 = *D.21297;
      if (D.21413 != reference) goto <D.21433>; else goto <D.21434>;
      <D.21433>:
      mono_assembly_close (reference);
      <D.21434>:
    }
  finally
    {
      aname = {CLOBBER};
      status = {CLOBBER};
    }
}


mono_assembly_invoke_search_hook_internal (struct MonoAssemblyName * aname, gboolean refonly, gboolean postload)
{
  int D.21438;
  int D.21441;
  struct MonoAssembly * (*<T1911>) (struct MonoAssemblyName *, void *) D.21444;
  void * D.21445;
  struct MonoAssembly * D.21448;
  struct AssemblySearchHook * hook;

  hook = assembly_search_hook;
  goto <D.19901>;
  <D.19900>:
  D.21438 = hook->refonly;
  if (D.21438 == refonly) goto <D.21439>; else goto <D.21440>;
  <D.21439>:
  D.21441 = hook->postload;
  if (D.21441 == postload) goto <D.21442>; else goto <D.21443>;
  <D.21442>:
  {
    struct MonoAssembly * ass;

    D.21444 = hook->func;
    D.21445 = hook->user_data;
    ass = D.21444 (aname, D.21445);
    if (ass != 0B) goto <D.21446>; else goto <D.21447>;
    <D.21446>:
    D.21448 = ass;
    return D.21448;
    <D.21447>:
  }
  <D.21443>:
  <D.21440>:
  hook = hook->next;
  <D.19901>:
  if (hook != 0B) goto <D.19900>; else goto <D.19902>;
  <D.19902>:
  D.21448 = 0B;
  return D.21448;
}


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


mono_assembly_invoke_load_hook (struct MonoAssembly * ass)
{
  void (*<T190a>) (struct MonoAssembly *, void *) D.21450;
  void * D.21451;
  struct AssemblyLoadHook * hook;

  hook = assembly_load_hook;
  goto <D.19870>;
  <D.19869>:
  D.21450 = hook->func;
  D.21451 = hook->user_data;
  D.21450 (ass, D.21451);
  hook = hook->next;
  <D.19870>:
  if (hook != 0B) goto <D.19869>; else goto <D.19871>;
  <D.19871>:
}


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

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


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

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


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

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

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

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


mono_assembly_open_from_bundle (const char * filename, MonoImageOpenStatus * status, gboolean refonly)
{
  const struct MonoBundledAssembly * * bundles.35;
  struct MonoImage * D.21473;
  _Bool D.21476;
  long int D.21477;
  long int D.21478;
  int D.20037;
  unsigned int i.36;
  unsigned int D.21482;
  const struct MonoBundledAssembly * * D.21483;
  const struct MonoBundledAssembly * D.21484;
  const char * D.21485;
  const unsigned char * D.21488;
  unsigned int D.21489;
  _Bool D.21493;
  long int D.21494;
  long int D.21495;
  int i;
  char * name;
  struct MonoImage * image;

  image = 0B;
  bundles.35 = bundles;
  if (bundles.35 == 0B) goto <D.21471>; else goto <D.21472>;
  <D.21471>:
  D.21473 = 0B;
  return D.21473;
  <D.21472>:
  name = monoeg_g_path_get_basename (filename);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21474>; else goto <D.21475>;
    <D.21474>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21475>:
    D.21476 = ret != 0;
    D.21477 = (long int) D.21476;
    D.21478 = __builtin_expect (D.21477, 0);
    if (D.21478 != 0) goto <D.21479>; else goto <D.21480>;
    <D.21479>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1466, "ret == 0");
    <D.21480>:
  }
  i = 0;
  goto <D.20040>;
  <D.20039>:
  {
    size_t __s1_len;
    size_t __s2_len;

    bundles.35 = bundles;
    i.36 = (unsigned int) i;
    D.21482 = i.36 * 4;
    D.21483 = bundles.35 + D.21482;
    D.21484 = *D.21483;
    D.21485 = D.21484->name;
    D.20037 = __builtin_strcmp (D.21485, name);
  }
  if (D.20037 == 0) goto <D.21486>; else goto <D.21487>;
  <D.21486>:
  bundles.35 = bundles;
  i.36 = (unsigned int) i;
  D.21482 = i.36 * 4;
  D.21483 = bundles.35 + D.21482;
  D.21484 = *D.21483;
  D.21488 = D.21484->data;
  bundles.35 = bundles;
  i.36 = (unsigned int) i;
  D.21482 = i.36 * 4;
  D.21483 = bundles.35 + D.21482;
  D.21484 = *D.21483;
  D.21489 = D.21484->size;
  image = mono_image_open_from_data_with_name (D.21488, D.21489, 0, status, refonly, name);
  goto <D.20038>;
  <D.21487>:
  i = i + 1;
  <D.20040>:
  if (image == 0B) goto <D.21490>; else goto <D.20038>;
  <D.21490>:
  bundles.35 = bundles;
  i.36 = (unsigned int) i;
  D.21482 = i.36 * 4;
  D.21483 = bundles.35 + D.21482;
  D.21484 = *D.21483;
  if (D.21484 != 0B) goto <D.20039>; else goto <D.20038>;
  <D.20038>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21491>; else goto <D.21492>;
    <D.21491>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21492>:
    D.21493 = ret != 0;
    D.21494 = (long int) D.21493;
    D.21495 = __builtin_expect (D.21494, 0);
    if (D.21495 != 0) goto <D.21496>; else goto <D.21497>;
    <D.21496>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1473, "ret == 0");
    <D.21497>:
  }
  monoeg_g_free (name);
  if (image != 0B) goto <D.21498>; else goto <D.21499>;
  <D.21498>:
  mono_image_addref (image);
  D.21473 = image;
  return D.21473;
  <D.21499>:
  D.21473 = 0B;
  return D.21473;
}


mono_assembly_open_full (const char * filename, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.21503;
  int D.21506;
  gchar * D.21509;
  char D.21510;
  struct GError * error.37;
  gchar * D.21518;
  unsigned char D.21520;
  _Bool D.21523;
  _Bool D.21524;
  _Bool D.21525;
  const struct MonoBundledAssembly * * bundles.38;
  <unnamed type> D.21535;
  struct MonoAssembly * D.21538;
  struct MonoImage * D.21545;
  struct MonoImage * image;
  struct MonoAssembly * ass;
  MonoImageOpenStatus def_status;
  gchar * fname;
  gchar * new_fname;

  try
    {
      if (filename == 0B) goto <D.21501>; else goto <D.21502>;
      <D.21501>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1491, "filename != NULL");
      D.21503 = 0B;
      return D.21503;
      <D.21502>:
      if (status == 0B) goto <D.21504>; else goto <D.21505>;
      <D.21504>:
      status = &def_status;
      <D.21505>:
      *status = 0;
      D.21506 = strncmp (filename, "file://", 7);
      if (D.21506 == 0) goto <D.21507>; else goto <D.21508>;
      <D.21507>:
      {
        struct GError * error;
        gchar * uri;
        gchar * tmpuri;

        try
          {
            error = 0B;
            uri = filename;
            D.21509 = uri + 7;
            D.21510 = *D.21509;
            if (D.21510 != 47) goto <D.21511>; else goto <D.21512>;
            <D.21511>:
            D.21509 = uri + 7;
            uri = monoeg_g_strdup_printf ("file:///%s", D.21509);
            <D.21512>:
            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.21513>; else goto <D.21514>;
            <D.21513>:
            monoeg_g_free (tmpuri);
            <D.21514>:
            error.37 = error;
            if (error.37 != 0B) goto <D.21516>; else goto <D.21517>;
            <D.21516>:
            error.37 = error;
            D.21518 = error.37->message;
            monoeg_g_log (0B, 16, "%s\n", D.21518);
            error.37 = error;
            monoeg_g_error_free (error.37);
            fname = monoeg_strdup (filename);
            <D.21517>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      goto <D.21519>;
      <D.21508>:
      fname = monoeg_strdup (filename);
      <D.21519>:
      mono_trace (64, 1, "Assembly Loader probing location: \'%s\'.", fname);
      new_fname = 0B;
      D.21520 = mono_assembly_is_in_gac (fname);
      if (D.21520 == 0) goto <D.21521>; else goto <D.21522>;
      <D.21521>:
      new_fname = mono_make_shadow_copy (fname);
      <D.21522>:
      D.21523 = new_fname != 0B;
      D.21524 = new_fname != fname;
      D.21525 = D.21523 & D.21524;
      if (D.21525 != 0) goto <D.21526>; else goto <D.21527>;
      <D.21526>:
      monoeg_g_free (fname);
      fname = new_fname;
      mono_trace (64, 1, "Assembly Loader shadow-copied assembly to: \'%s\'.", fname);
      <D.21527>:
      image = 0B;
      bundles.38 = bundles;
      if (bundles.38 != 0B) goto <D.21529>; else goto <D.21530>;
      <D.21529>:
      image = mono_assembly_open_from_bundle (fname, status, refonly);
      <D.21530>:
      if (image == 0B) goto <D.21531>; else goto <D.21532>;
      <D.21531>:
      image = mono_image_open_full (fname, status, refonly);
      <D.21532>:
      if (image == 0B) goto <D.21533>; else goto <D.21534>;
      <D.21533>:
      D.21535 = *status;
      if (D.21535 == 0) goto <D.21536>; else goto <D.21537>;
      <D.21536>:
      *status = 1;
      <D.21537>:
      monoeg_g_free (fname);
      D.21503 = 0B;
      return D.21503;
      <D.21534>:
      D.21538 = image->assembly;
      if (D.21538 != 0B) goto <D.21539>; else goto <D.21540>;
      <D.21539>:
      D.21538 = image->assembly;
      mono_assembly_invoke_load_hook (D.21538);
      mono_image_close (image);
      monoeg_g_free (fname);
      D.21503 = image->assembly;
      return D.21503;
      <D.21540>:
      ass = mono_assembly_load_from_full (image, fname, status, refonly);
      if (ass != 0B) goto <D.21541>; else goto <D.21542>;
      <D.21541>:
      mono_trace (64, 1, "Assembly Loader loaded assembly from location: \'%s\'.", filename);
      if (refonly == 0) goto <D.21543>; else goto <D.21544>;
      <D.21543>:
      D.21545 = ass->image;
      mono_config_for_assembly (D.21545);
      <D.21544>:
      <D.21542>:
      mono_image_close (image);
      monoeg_g_free (fname);
      D.21503 = ass;
      return D.21503;
    }
  finally
    {
      def_status = {CLOBBER};
    }
}


mono_assembly_is_in_gac (const gchar * filename)
{
  MonoBoolean D.21550;
  gchar * D.21551;
  char * D.21552;
  unsigned int D.21555;
  char D.21556;
  int D.21559;
  int D.21564;
  int D.21569;
  char * D.21575;
  unsigned int D.21578;
  int D.21581;
  int D.21586;
  const gchar * rootdir;
  gchar * gp;
  gchar * * paths;

  if (filename == 0B) goto <D.21548>; else goto <D.21549>;
  <D.21548>:
  D.21550 = 0;
  return D.21550;
  <D.21549>:
  paths = extra_gac_paths;
  goto <D.20345>;
  <D.20344>:
  D.21551 = *paths;
  D.21552 = strstr (D.21551, filename);
  D.21551 = *paths;
  if (D.21552 != D.21551) goto <D.21553>; else goto <D.21554>;
  <D.21553>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21554>:
  D.21551 = *paths;
  D.21555 = strlen (D.21551);
  gp = filename + D.21555;
  D.21556 = *gp;
  if (D.21556 != 47) goto <D.21557>; else goto <D.21558>;
  <D.21557>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21558>:
  gp = gp + 1;
  D.21559 = strncmp (gp, "lib", 3);
  if (D.21559 != 0) goto <D.21560>; else goto <D.21561>;
  <D.21560>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21561>:
  gp = gp + 3;
  D.21556 = *gp;
  if (D.21556 != 47) goto <D.21562>; else goto <D.21563>;
  <D.21562>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21563>:
  gp = gp + 1;
  D.21564 = strncmp (gp, "mono", 4);
  if (D.21564 != 0) goto <D.21565>; else goto <D.21566>;
  <D.21565>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21566>:
  gp = gp + 4;
  D.21556 = *gp;
  if (D.21556 != 47) goto <D.21567>; else goto <D.21568>;
  <D.21567>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21568>:
  gp = gp + 1;
  D.21569 = strncmp (gp, "gac", 3);
  if (D.21569 != 0) goto <D.21570>; else goto <D.21571>;
  <D.21570>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21571>:
  gp = gp + 3;
  D.21556 = *gp;
  if (D.21556 != 47) goto <D.21572>; else goto <D.21573>;
  <D.21572>:
  // predicted unlikely by continue predictor.
  goto <D.20316>;
  <D.21573>:
  D.21550 = 1;
  return D.21550;
  <D.20316>:
  paths = paths + 4;
  <D.20345>:
  if (paths != 0B) goto <D.21574>; else goto <D.20346>;
  <D.21574>:
  D.21551 = *paths;
  if (D.21551 != 0B) goto <D.20344>; else goto <D.20346>;
  <D.20346>:
  rootdir = mono_assembly_getrootdir ();
  D.21575 = strstr (filename, rootdir);
  if (D.21575 != filename) goto <D.21576>; else goto <D.21577>;
  <D.21576>:
  D.21550 = 0;
  return D.21550;
  <D.21577>:
  D.21578 = strlen (rootdir);
  gp = filename + D.21578;
  D.21556 = *gp;
  if (D.21556 != 47) goto <D.21579>; else goto <D.21580>;
  <D.21579>:
  D.21550 = 0;
  return D.21550;
  <D.21580>:
  gp = gp + 1;
  D.21581 = strncmp (gp, "mono", 4);
  if (D.21581 != 0) goto <D.21582>; else goto <D.21583>;
  <D.21582>:
  D.21550 = 0;
  return D.21550;
  <D.21583>:
  gp = gp + 4;
  D.21556 = *gp;
  if (D.21556 != 47) goto <D.21584>; else goto <D.21585>;
  <D.21584>:
  D.21550 = 0;
  return D.21550;
  <D.21585>:
  gp = gp + 1;
  D.21586 = strncmp (gp, "gac", 3);
  if (D.21586 != 0) goto <D.21587>; else goto <D.21588>;
  <D.21587>:
  D.21550 = 0;
  return D.21550;
  <D.21588>:
  gp = gp + 3;
  D.21556 = *gp;
  if (D.21556 != 47) goto <D.21589>; else goto <D.21590>;
  <D.21589>:
  D.21550 = 0;
  return D.21550;
  <D.21590>:
  D.21550 = 1;
  return D.21550;
}


mono_assembly_load_friends (struct MonoAssembly * ass)
{
  unsigned char D.21592;
  _Bool D.21599;
  long int D.21600;
  long int D.21601;
  _Bool D.21606;
  long int D.21607;
  long int D.21608;
  _Bool D.21613;
  long int D.21614;
  long int D.21615;
  _Bool D.21622;
  long int D.21623;
  long int D.21624;
  _Bool D.21629;
  long int D.21630;
  long int D.21631;
  struct MonoMethod * D.21636;
  struct MonoClass * D.21638;
  struct MonoClass * D.21639;
  unsigned int D.21640;
  const mono_byte * data.39;
  const gchar * data.40;
  char D.21647;
  const gchar * D.21649;
  char D.21650;
  const gchar * D.21652;
  char D.21653;
  const char * D.21654;
  int D.21655;
  int D.21659;
  _Bool D.21662;
  long int D.21663;
  long int D.21664;
  _Bool D.21671;
  long int D.21672;
  long int D.21673;
  _Bool D.21678;
  long int D.21679;
  long int D.21680;
  int i;
  struct MonoCustomAttrInfo * attrs;
  struct GSList * list;

  D.21592 = ass->friend_assembly_names_inited;
  if (D.21592 != 0) goto <D.21593>; else goto <D.21594>;
  <D.21593>:
  return;
  <D.21594>:
  attrs = mono_custom_attrs_from_assembly (ass);
  if (attrs == 0B) goto <D.21595>; else goto <D.21596>;
  <D.21595>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21597>; else goto <D.21598>;
    <D.21597>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21598>:
    D.21599 = ret != 0;
    D.21600 = (long int) D.21599;
    D.21601 = __builtin_expect (D.21600, 0);
    if (D.21601 != 0) goto <D.21602>; else goto <D.21603>;
    <D.21602>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1611, "ret == 0");
    <D.21603>:
  }
  ass->friend_assembly_names_inited = 1;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21604>; else goto <D.21605>;
    <D.21604>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21605>:
    D.21606 = ret != 0;
    D.21607 = (long int) D.21606;
    D.21608 = __builtin_expect (D.21607, 0);
    if (D.21608 != 0) goto <D.21609>; else goto <D.21610>;
    <D.21609>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1613, "ret == 0");
    <D.21610>:
  }
  return;
  <D.21596>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21611>; else goto <D.21612>;
    <D.21611>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21612>:
    D.21613 = ret != 0;
    D.21614 = (long int) D.21613;
    D.21615 = __builtin_expect (D.21614, 0);
    if (D.21615 != 0) goto <D.21616>; else goto <D.21617>;
    <D.21616>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1617, "ret == 0");
    <D.21617>:
  }
  D.21592 = ass->friend_assembly_names_inited;
  if (D.21592 != 0) goto <D.21618>; else goto <D.21619>;
  <D.21618>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21620>; else goto <D.21621>;
    <D.21620>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21621>:
    D.21622 = ret != 0;
    D.21623 = (long int) D.21622;
    D.21624 = __builtin_expect (D.21623, 0);
    if (D.21624 != 0) goto <D.21625>; else goto <D.21626>;
    <D.21625>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1619, "ret == 0");
    <D.21626>:
  }
  return;
  <D.21619>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21627>; else goto <D.21628>;
    <D.21627>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21628>:
    D.21629 = ret != 0;
    D.21630 = (long int) D.21629;
    D.21631 = __builtin_expect (D.21630, 0);
    if (D.21631 != 0) goto <D.21632>; else goto <D.21633>;
    <D.21632>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1622, "ret == 0");
    <D.21633>:
  }
  list = 0B;
  i = 0;
  goto <D.20085>;
  <D.20084>:
  {
    struct MonoCustomAttrEntry * attr;
    struct MonoAssemblyName * aname;
    const gchar * data;
    guint slen;

    try
      {
        attr = &attrs->attrs[i];
        D.21636 = attr->ctor;
        if (D.21636 == 0B) goto <D.21634>; else goto <D.21637>;
        <D.21637>:
        D.21636 = attr->ctor;
        D.21638 = D.21636->klass;
        D.21639 = mono_defaults.internals_visible_class;
        if (D.21638 != D.21639) goto <D.21634>; else goto <D.21635>;
        <D.21634>:
        // predicted unlikely by continue predictor.
        goto <D.20083>;
        <D.21635>:
        D.21640 = attr->data_size;
        if (D.21640 <= 3) goto <D.21641>; else goto <D.21642>;
        <D.21641>:
        // predicted unlikely by continue predictor.
        goto <D.20083>;
        <D.21642>:
        data.39 = attr->data;
        data = data.39;
        data.40 = data;
        D.21647 = *data.40;
        if (D.21647 != 1) goto <D.21644>; else goto <D.21648>;
        <D.21648>:
        data.40 = data;
        D.21649 = data.40 + 1;
        D.21650 = *D.21649;
        if (D.21650 != 0) goto <D.21644>; else goto <D.21651>;
        <D.21651>:
        data.40 = data;
        D.21652 = data.40 + 2;
        D.21653 = *D.21652;
        if (D.21653 == 255) goto <D.21644>; else goto <D.21645>;
        <D.21644>:
        // predicted unlikely by continue predictor.
        goto <D.20083>;
        <D.21645>:
        data.40 = data;
        D.21654 = data.40 + 2;
        slen = mono_metadata_decode_value (D.21654, &data);
        aname = monoeg_malloc0 (60);
        data.40 = data;
        D.21655 = mono_assembly_name_parse_full (data.40, aname, 1, 0B, 0B);
        if (D.21655 != 0) goto <D.21656>; else goto <D.21657>;
        <D.21656>:
        list = monoeg_g_slist_prepend (list, aname);
        goto <D.21658>;
        <D.21657>:
        monoeg_g_free (aname);
        <D.21658>:
      }
    finally
      {
        data = {CLOBBER};
      }
  }
  <D.20083>:
  i = i + 1;
  <D.20085>:
  D.21659 = attrs->num_attrs;
  if (D.21659 > i) goto <D.20084>; else goto <D.20086>;
  <D.20086>:
  mono_custom_attrs_free (attrs);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21660>; else goto <D.21661>;
    <D.21660>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21661>:
    D.21662 = ret != 0;
    D.21663 = (long int) D.21662;
    D.21664 = __builtin_expect (D.21663, 0);
    if (D.21664 != 0) goto <D.21665>; else goto <D.21666>;
    <D.21665>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1654, "ret == 0");
    <D.21666>:
  }
  D.21592 = ass->friend_assembly_names_inited;
  if (D.21592 != 0) goto <D.21667>; else goto <D.21668>;
  <D.21667>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21669>; else goto <D.21670>;
    <D.21669>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21670>:
    D.21671 = ret != 0;
    D.21672 = (long int) D.21671;
    D.21673 = __builtin_expect (D.21672, 0);
    if (D.21673 != 0) goto <D.21674>; else goto <D.21675>;
    <D.21674>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1656, "ret == 0");
    <D.21675>:
  }
  monoeg_g_slist_foreach (list, free_item, 0B);
  monoeg_g_slist_free (list);
  return;
  <D.21668>:
  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.21676>; else goto <D.21677>;
    <D.21676>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21677>:
    D.21678 = ret != 0;
    D.21679 = (long int) D.21678;
    D.21680 = __builtin_expect (D.21679, 0);
    if (D.21680 != 0) goto <D.21681>; else goto <D.21682>;
    <D.21681>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1666, "ret == 0");
    <D.21682>:
  }
}


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

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


mono_assembly_load_from_full (struct MonoImage * image, const char * fname, MonoImageOpenStatus * status, gboolean refonly)
{
  unsigned int D.21688;
  unsigned int D.21689;
  struct MonoAssembly * D.21692;
  struct MonoAssemblyName * D.21693;
  struct MonoImage * D.21694;
  int D.20111;
  int iftmp.41;
  int D.20110;
  const char[9] * D.21700;
  unsigned char D.21701;
  int D.21702;
  unsigned char D.21703;
  int D.21704;
  _Bool D.21705;
  _Bool D.21706;
  _Bool D.21707;
  const unsigned char * D.21710;
  unsigned char D.21711;
  int D.21712;
  const unsigned char * D.21713;
  unsigned char D.21714;
  int D.21715;
  _Bool D.21716;
  _Bool D.21717;
  const unsigned char * D.21720;
  unsigned char D.21721;
  int D.21722;
  const unsigned char * D.21723;
  unsigned char D.21724;
  int D.21725;
  _Bool D.21726;
  _Bool D.21727;
  const unsigned char * D.21730;
  unsigned char D.21731;
  int D.21732;
  const unsigned char * D.21733;
  unsigned char D.21734;
  int D.21735;
  const char * D.21737;
  char * D.21740;
  int D.21741;
  _Bool D.21748;
  long int D.21749;
  long int D.21750;
  struct MonoAssembly * D.21753;
  _Bool D.21758;
  long int D.21759;
  long int D.21760;
  struct GList * loaded_assemblies.42;
  struct GList * loaded_assemblies.43;
  _Bool D.21767;
  long int D.21768;
  long int D.21769;
  struct MonoAssembly * ass;
  struct MonoAssembly * ass2;
  char * base_dir;

  D.21688 = BIT_FIELD_REF <*image, 32, 3904>;
  D.21689 = D.21688 & 16777215;
  if (D.21689 == 0) goto <D.21690>; else goto <D.21691>;
  <D.21690>:
  *status = 3;
  D.21692 = 0B;
  return D.21692;
  <D.21691>:
  base_dir = absolute_dir (fname);
  ass = monoeg_malloc0 (92);
  ass->basedir = base_dir;
  ass->ref_only = refonly;
  ass->image = image;
  mono_profiler_assembly_event (ass, 0);
  D.21693 = &ass->aname;
  mono_assembly_fill_assembly_name (image, D.21693);
  D.21694 = mono_defaults.corlib;
  if (D.21694 != 0B) goto <D.21695>; else goto <D.21696>;
  <D.21695>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ass->aname.name;
      D.21700 = "mscorlib";
      D.21701 = MEM[(const unsigned char *)D.21700];
      D.21702 = (int) D.21701;
      D.21703 = *__s2;
      D.21704 = (int) D.21703;
      __result = D.21702 - D.21704;
      {
        D.21705 = __s2_len != 0;
        D.21706 = __result == 0;
        D.21707 = D.21705 & D.21706;
        if (D.21707 != 0) goto <D.21708>; else goto <D.21709>;
        <D.21708>:
        D.21710 = &MEM[(void *)"mscorlib" + 1B];
        D.21711 = *D.21710;
        D.21712 = (int) D.21711;
        D.21713 = __s2 + 1;
        D.21714 = *D.21713;
        D.21715 = (int) D.21714;
        __result = D.21712 - D.21715;
        D.21716 = __s2_len > 1;
        D.21706 = __result == 0;
        D.21717 = D.21716 & D.21706;
        if (D.21717 != 0) goto <D.21718>; else goto <D.21719>;
        <D.21718>:
        D.21720 = &MEM[(void *)"mscorlib" + 2B];
        D.21721 = *D.21720;
        D.21722 = (int) D.21721;
        D.21723 = __s2 + 2;
        D.21724 = *D.21723;
        D.21725 = (int) D.21724;
        __result = D.21722 - D.21725;
        D.21726 = __s2_len > 2;
        D.21706 = __result == 0;
        D.21727 = D.21726 & D.21706;
        if (D.21727 != 0) goto <D.21728>; else goto <D.21729>;
        <D.21728>:
        D.21730 = &MEM[(void *)"mscorlib" + 3B];
        D.21731 = *D.21730;
        D.21732 = (int) D.21731;
        D.21733 = __s2 + 3;
        D.21734 = *D.21733;
        D.21735 = (int) D.21734;
        __result = D.21732 - D.21735;
        <D.21729>:
        <D.21719>:
        <D.21709>:
      }
      D.20110 = __result;
    }
    iftmp.41 = -D.20110;
    goto <D.21736>;
    <D.21699>:
    D.21737 = ass->aname.name;
    iftmp.41 = __builtin_strcmp (D.21737, "mscorlib");
    <D.21736>:
    D.20111 = iftmp.41;
  }
  if (D.20111 == 0) goto <D.21738>; else goto <D.21739>;
  <D.21738>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  D.21694 = mono_defaults.corlib;
  mono_image_addref (D.21694);
  *status = 0;
  D.21694 = mono_defaults.corlib;
  D.21692 = D.21694->assembly;
  return D.21692;
  <D.21739>:
  <D.21696>:
  mono_image_addref (image);
  D.21737 = ass->aname.name;
  D.21740 = image->name;
  D.21741 = image->ref_count;
  mono_trace (64, 1, "Image addref %s[%p] -> %s[%p]: %d", D.21737, ass, D.21740, image, D.21741);
  D.21737 = ass->aname.name;
  if (D.21737 != 0B) goto <D.21742>; else goto <D.21743>;
  <D.21742>:
  D.21693 = &ass->aname;
  ass2 = mono_assembly_invoke_search_hook_internal (D.21693, refonly, 0);
  if (ass2 != 0B) goto <D.21744>; else goto <D.21745>;
  <D.21744>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.21692 = ass2;
  return D.21692;
  <D.21745>:
  <D.21743>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21746>; else goto <D.21747>;
    <D.21746>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21747>:
    D.21748 = ret != 0;
    D.21749 = (long int) D.21748;
    D.21750 = __builtin_expect (D.21749, 0);
    if (D.21750 != 0) goto <D.21751>; else goto <D.21752>;
    <D.21751>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1759, "ret == 0");
    <D.21752>:
  }
  D.21753 = image->assembly;
  if (D.21753 != 0B) goto <D.21754>; else goto <D.21755>;
  <D.21754>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21756>; else goto <D.21757>;
    <D.21756>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21757>:
    D.21758 = ret != 0;
    D.21759 = (long int) D.21758;
    D.21760 = __builtin_expect (D.21759, 0);
    if (D.21760 != 0) goto <D.21761>; else goto <D.21762>;
    <D.21761>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1766, "ret == 0");
    <D.21762>:
  }
  ass2 = image->assembly;
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.21692 = ass2;
  return D.21692;
  <D.21755>:
  image->assembly = ass;
  loaded_assemblies.42 = loaded_assemblies;
  loaded_assemblies.43 = monoeg_g_list_prepend (loaded_assemblies.42, ass);
  loaded_assemblies = loaded_assemblies.43;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.21765>; else goto <D.21766>;
    <D.21765>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21766>:
    D.21767 = ret != 0;
    D.21768 = (long int) D.21767;
    D.21769 = __builtin_expect (D.21768, 0);
    if (D.21769 != 0) goto <D.21770>; else goto <D.21771>;
    <D.21770>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1778, "ret == 0");
    <D.21771>:
  }
  mono_assembly_invoke_load_hook (ass);
  mono_profiler_assembly_loaded (ass, 0);
  D.21692 = ass;
  return D.21692;
}


absolute_dir (const gchar * filename)
{
  int D.21773;
  gchar * D.21776;
  int D.20003;
  int iftmp.44;
  int D.20002;
  const char[2] * D.21780;
  unsigned char D.21781;
  int D.21782;
  unsigned char D.21783;
  int D.21784;
  _Bool D.21785;
  _Bool D.21786;
  _Bool D.21787;
  const unsigned char * D.21790;
  unsigned char D.21791;
  int D.21792;
  const unsigned char * D.21793;
  unsigned char D.21794;
  int D.21795;
  _Bool D.21796;
  _Bool D.21797;
  const unsigned char * D.21800;
  unsigned char D.21801;
  int D.21802;
  const unsigned char * D.21803;
  unsigned char D.21804;
  int D.21805;
  _Bool D.21806;
  _Bool D.21807;
  const unsigned char * D.21810;
  unsigned char D.21811;
  int D.21812;
  const unsigned char * D.21813;
  unsigned char D.21814;
  int D.21815;
  int D.20013;
  int iftmp.45;
  int D.20012;
  const char[3] * D.21822;
  unsigned char D.21823;
  int D.21824;
  unsigned char D.21825;
  int D.21826;
  _Bool D.21827;
  _Bool D.21828;
  _Bool D.21829;
  const unsigned char * D.21832;
  unsigned char D.21833;
  int D.21834;
  const unsigned char * D.21835;
  unsigned char D.21836;
  int D.21837;
  _Bool D.21838;
  _Bool D.21839;
  const unsigned char * D.21842;
  unsigned char D.21843;
  int D.21844;
  const unsigned char * D.21845;
  unsigned char D.21846;
  int D.21847;
  _Bool D.21848;
  _Bool D.21849;
  const unsigned char * D.21852;
  unsigned char D.21853;
  int D.21854;
  const unsigned char * D.21855;
  unsigned char D.21856;
  int D.21857;
  struct GList * D.21863;
  unsigned int i.46;
  unsigned int D.21868;
  gchar * * D.21869;
  void * D.21870;
  struct GList * D.21874;
  char D.21875;
  gchar * cwd;
  gchar * mixed;
  gchar * * parts;
  gchar * part;
  struct GList * list;
  struct GList * tmp;
  struct GString * result;
  gchar * res;
  gint i;

  D.21773 = monoeg_g_path_is_absolute (filename);
  if (D.21773 != 0) goto <D.21774>; else goto <D.21775>;
  <D.21774>:
  part = monoeg_g_path_get_dirname (filename);
  res = monoeg_g_strconcat (part, "/", 0B);
  monoeg_g_free (part);
  D.21776 = res;
  return D.21776;
  <D.21775>:
  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.20015>;
  <D.20014>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = part;
      D.21780 = ".";
      D.21781 = MEM[(const unsigned char *)D.21780];
      D.21782 = (int) D.21781;
      D.21783 = *__s2;
      D.21784 = (int) D.21783;
      __result = D.21782 - D.21784;
      {
        D.21785 = __s2_len != 0;
        D.21786 = __result == 0;
        D.21787 = D.21785 & D.21786;
        if (D.21787 != 0) goto <D.21788>; else goto <D.21789>;
        <D.21788>:
        D.21790 = &MEM[(void *)"." + 1B];
        D.21791 = *D.21790;
        D.21792 = (int) D.21791;
        D.21793 = __s2 + 1;
        D.21794 = *D.21793;
        D.21795 = (int) D.21794;
        __result = D.21792 - D.21795;
        D.21796 = __s2_len > 1;
        D.21786 = __result == 0;
        D.21797 = D.21796 & D.21786;
        if (D.21797 != 0) goto <D.21798>; else goto <D.21799>;
        <D.21798>:
        D.21800 = &MEM[(void *)"." + 2B];
        D.21801 = *D.21800;
        D.21802 = (int) D.21801;
        D.21803 = __s2 + 2;
        D.21804 = *D.21803;
        D.21805 = (int) D.21804;
        __result = D.21802 - D.21805;
        D.21806 = __s2_len > 2;
        D.21786 = __result == 0;
        D.21807 = D.21806 & D.21786;
        if (D.21807 != 0) goto <D.21808>; else goto <D.21809>;
        <D.21808>:
        D.21810 = &MEM[(void *)"." + 3B];
        D.21811 = *D.21810;
        D.21812 = (int) D.21811;
        D.21813 = __s2 + 3;
        D.21814 = *D.21813;
        D.21815 = (int) D.21814;
        __result = D.21812 - D.21815;
        <D.21809>:
        <D.21799>:
        <D.21789>:
      }
      D.20002 = __result;
    }
    iftmp.44 = -D.20002;
    goto <D.21816>;
    <D.21779>:
    iftmp.44 = __builtin_strcmp (part, ".");
    <D.21816>:
    D.20003 = iftmp.44;
  }
  if (D.20003 == 0) goto <D.21817>; else goto <D.21818>;
  <D.21817>:
  // predicted unlikely by continue predictor.
  goto <D.20004>;
  <D.21818>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = part;
      D.21822 = "..";
      D.21823 = MEM[(const unsigned char *)D.21822];
      D.21824 = (int) D.21823;
      D.21825 = *__s2;
      D.21826 = (int) D.21825;
      __result = D.21824 - D.21826;
      {
        D.21827 = __s2_len != 0;
        D.21828 = __result == 0;
        D.21829 = D.21827 & D.21828;
        if (D.21829 != 0) goto <D.21830>; else goto <D.21831>;
        <D.21830>:
        D.21832 = &MEM[(void *)".." + 1B];
        D.21833 = *D.21832;
        D.21834 = (int) D.21833;
        D.21835 = __s2 + 1;
        D.21836 = *D.21835;
        D.21837 = (int) D.21836;
        __result = D.21834 - D.21837;
        D.21838 = __s2_len > 1;
        D.21828 = __result == 0;
        D.21839 = D.21838 & D.21828;
        if (D.21839 != 0) goto <D.21840>; else goto <D.21841>;
        <D.21840>:
        D.21842 = &MEM[(void *)".." + 2B];
        D.21843 = *D.21842;
        D.21844 = (int) D.21843;
        D.21845 = __s2 + 2;
        D.21846 = *D.21845;
        D.21847 = (int) D.21846;
        __result = D.21844 - D.21847;
        D.21848 = __s2_len > 2;
        D.21828 = __result == 0;
        D.21849 = D.21848 & D.21828;
        if (D.21849 != 0) goto <D.21850>; else goto <D.21851>;
        <D.21850>:
        D.21852 = &MEM[(void *)".." + 3B];
        D.21853 = *D.21852;
        D.21854 = (int) D.21853;
        D.21855 = __s2 + 3;
        D.21856 = *D.21855;
        D.21857 = (int) D.21856;
        __result = D.21854 - D.21857;
        <D.21851>:
        <D.21841>:
        <D.21831>:
      }
      D.20012 = __result;
    }
    iftmp.45 = -D.20012;
    goto <D.21858>;
    <D.21821>:
    iftmp.45 = __builtin_strcmp (part, "..");
    <D.21858>:
    D.20013 = iftmp.45;
  }
  if (D.20013 == 0) goto <D.21859>; else goto <D.21860>;
  <D.21859>:
  if (list != 0B) goto <D.21861>; else goto <D.21862>;
  <D.21861>:
  D.21863 = list->next;
  if (D.21863 != 0B) goto <D.21864>; else goto <D.21865>;
  <D.21864>:
  list = monoeg_g_list_delete_link (list, list);
  <D.21865>:
  <D.21862>:
  goto <D.21866>;
  <D.21860>:
  list = monoeg_g_list_prepend (list, part);
  <D.21866>:
  <D.20004>:
  i = i + 1;
  <D.20015>:
  i.46 = (unsigned int) i;
  D.21868 = i.46 * 4;
  D.21869 = parts + D.21868;
  part = *D.21869;
  if (part != 0B) goto <D.20014>; else goto <D.20016>;
  <D.20016>:
  result = monoeg_g_string_new ("");
  list = monoeg_g_list_reverse (list);
  tmp = list;
  goto <D.20018>;
  <D.20017>:
  D.21870 = tmp->data;
  if (D.21870 != 0B) goto <D.21871>; else goto <D.21872>;
  <D.21871>:
  D.21870 = tmp->data;
  monoeg_g_string_append_printf (result, "%s%c", D.21870, 47);
  <D.21872>:
  tmp = tmp->next;
  <D.20018>:
  if (tmp != 0B) goto <D.21873>; else goto <D.20019>;
  <D.21873>:
  D.21874 = tmp->next;
  if (D.21874 != 0B) goto <D.20017>; else goto <D.20019>;
  <D.20019>:
  res = result->str;
  monoeg_g_string_free (result, 0);
  monoeg_g_list_free (list);
  monoeg_g_strfreev (parts);
  D.21875 = *res;
  if (D.21875 == 0) goto <D.21876>; else goto <D.21877>;
  <D.21876>:
  monoeg_g_free (res);
  D.21776 = monoeg_strdup (".");
  return D.21776;
  <D.21877>:
  D.21776 = res;
  return D.21776;
}


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

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


mono_assembly_name_free (struct MonoAssemblyName * aname)
{
  const char * D.21883;
  const char * D.21884;
  const char * D.21885;

  if (aname == 0B) goto <D.21881>; else goto <D.21882>;
  <D.21881>:
  return;
  <D.21882>:
  D.21883 = aname->name;
  monoeg_g_free (D.21883);
  D.21884 = aname->culture;
  monoeg_g_free (D.21884);
  D.21885 = aname->hash_value;
  monoeg_g_free (D.21885);
}


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.21894;
  gboolean D.21895;
  gchar * D.21896;
  gchar * D.21897;
  gchar * D.21898;
  int D.21899;
  unsigned int part_name_len.47;
  gchar * part_name.48;
  int D.21905;
  char D.21908;
  int D.21912;
  char D.21915;
  int D.21919;
  char D.21922;
  int D.21926;
  char D.21929;
  int D.21933;
  char D.21936;
  int D.21938;
  int D.21942;
  int D.21946;
  gchar * value.49;
  int D.21950;
  int D.21954;
  int D.21958;
  int D.21962;
  int D.21966;
  _Bool D.21970;
  _Bool D.21971;
  _Bool D.21972;
  _Bool D.21974;
  _Bool D.21975;
  _Bool D.21976;
  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.21887>; else goto <D.21888>;
      <D.21887>:
      is_version_defined = &version_defined;
      <D.21888>:
      *is_version_defined = 0;
      if (is_token_defined == 0B) goto <D.21889>; else goto <D.21890>;
      <D.21889>:
      is_token_defined = &token_defined;
      <D.21890>:
      *is_token_defined = 0;
      tmp = monoeg_g_strsplit (name, ",", 6);
      parts = tmp;
      if (tmp == 0B) goto <D.21891>; else goto <D.21893>;
      <D.21893>:
      D.21894 = *tmp;
      if (D.21894 == 0B) goto <D.21891>; else goto <D.21892>;
      <D.21891>:
      monoeg_g_strfreev (tmp);
      D.21895 = 0;
      return D.21895;
      <D.21892>:
      D.21894 = *tmp;
      D.21896 = monoeg_g_strchomp (D.21894);
      dllname = monoeg_g_strchug (D.21896);
      tmp = tmp + 4;
      goto <D.20239>;
      <D.20240>:
      D.21894 = *tmp;
      D.21897 = monoeg_g_strchomp (D.21894);
      D.21898 = monoeg_g_strchug (D.21897);
      D.21899 = split_key_value (D.21898, &part_name, &part_name_len, &value);
      if (D.21899 == 0) goto cleanup_and_fail; else goto <D.21900>;
      <D.21900>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 7) goto <D.21902>; else goto <D.21903>;
      <D.21902>:
      part_name.48 = part_name;
      part_name_len.47 = part_name_len;
      D.21905 = monoeg_g_ascii_strncasecmp (part_name.48, "Version", part_name_len.47);
      if (D.21905 == 0) goto <D.21906>; else goto <D.21907>;
      <D.21906>:
      *is_version_defined = 1;
      version = value;
      D.21908 = MEM[(const char *)version];
      if (D.21908 == 0) goto cleanup_and_fail; else goto <D.21909>;
      <D.21909>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.20239>;
      <D.21907>:
      <D.21903>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 7) goto <D.21910>; else goto <D.21911>;
      <D.21910>:
      part_name.48 = part_name;
      part_name_len.47 = part_name_len;
      D.21912 = monoeg_g_ascii_strncasecmp (part_name.48, "Culture", part_name_len.47);
      if (D.21912 == 0) goto <D.21913>; else goto <D.21914>;
      <D.21913>:
      culture = value;
      D.21915 = MEM[(const char *)culture];
      if (D.21915 == 0) goto cleanup_and_fail; else goto <D.21916>;
      <D.21916>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.20239>;
      <D.21914>:
      <D.21911>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 14) goto <D.21917>; else goto <D.21918>;
      <D.21917>:
      part_name.48 = part_name;
      part_name_len.47 = part_name_len;
      D.21919 = monoeg_g_ascii_strncasecmp (part_name.48, "PublicKeyToken", part_name_len.47);
      if (D.21919 == 0) goto <D.21920>; else goto <D.21921>;
      <D.21920>:
      *is_token_defined = 1;
      token = value;
      D.21922 = MEM[(const char *)token];
      if (D.21922 == 0) goto cleanup_and_fail; else goto <D.21923>;
      <D.21923>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.20239>;
      <D.21921>:
      <D.21918>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 9) goto <D.21924>; else goto <D.21925>;
      <D.21924>:
      part_name.48 = part_name;
      part_name_len.47 = part_name_len;
      D.21926 = monoeg_g_ascii_strncasecmp (part_name.48, "PublicKey", part_name_len.47);
      if (D.21926 == 0) goto <D.21927>; else goto <D.21928>;
      <D.21927>:
      key = value;
      D.21929 = MEM[(const char *)key];
      if (D.21929 == 0) goto cleanup_and_fail; else goto <D.21930>;
      <D.21930>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.20239>;
      <D.21928>:
      <D.21925>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 12) goto <D.21931>; else goto <D.21932>;
      <D.21931>:
      part_name.48 = part_name;
      part_name_len.47 = part_name_len;
      D.21933 = monoeg_g_ascii_strncasecmp (part_name.48, "Retargetable", part_name_len.47);
      if (D.21933 == 0) goto <D.21934>; else goto <D.21935>;
      <D.21934>:
      retargetable = value;
      D.21936 = MEM[(const char *)retargetable];
      if (D.21936 == 0) goto cleanup_and_fail; else goto <D.21937>;
      <D.21937>:
      D.21938 = monoeg_ascii_strcasecmp (retargetable, "yes");
      if (D.21938 == 0) goto <D.21939>; else goto <D.21940>;
      <D.21939>:
      flags = flags | 256;
      goto <D.21941>;
      <D.21940>:
      D.21942 = monoeg_ascii_strcasecmp (retargetable, "no");
      if (D.21942 != 0) goto cleanup_and_fail; else goto <D.21943>;
      <D.21943>:
      <D.21941>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.20239>;
      <D.21935>:
      <D.21932>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 21) goto <D.21944>; else goto <D.21945>;
      <D.21944>:
      part_name.48 = part_name;
      part_name_len.47 = part_name_len;
      D.21946 = monoeg_g_ascii_strncasecmp (part_name.48, "ProcessorArchitecture", part_name_len.47);
      if (D.21946 == 0) goto <D.21947>; else goto <D.21948>;
      <D.21947>:
      value.49 = value;
      D.21950 = monoeg_ascii_strcasecmp (value.49, "None");
      if (D.21950 == 0) goto <D.21951>; else goto <D.21952>;
      <D.21951>:
      arch = 0;
      goto <D.21953>;
      <D.21952>:
      value.49 = value;
      D.21954 = monoeg_ascii_strcasecmp (value.49, "MSIL");
      if (D.21954 == 0) goto <D.21955>; else goto <D.21956>;
      <D.21955>:
      arch = 1;
      goto <D.21957>;
      <D.21956>:
      value.49 = value;
      D.21958 = monoeg_ascii_strcasecmp (value.49, "X86");
      if (D.21958 == 0) goto <D.21959>; else goto <D.21960>;
      <D.21959>:
      arch = 2;
      goto <D.21961>;
      <D.21960>:
      value.49 = value;
      D.21962 = monoeg_ascii_strcasecmp (value.49, "IA64");
      if (D.21962 == 0) goto <D.21963>; else goto <D.21964>;
      <D.21963>:
      arch = 3;
      goto <D.21965>;
      <D.21964>:
      value.49 = value;
      D.21966 = monoeg_ascii_strcasecmp (value.49, "AMD64");
      if (D.21966 == 0) goto <D.21967>; else goto cleanup_and_fail;
      <D.21967>:
      arch = 4;
      <D.21965>:
      <D.21961>:
      <D.21957>:
      <D.21953>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.20239>;
      <D.21948>:
      <D.21945>:
      monoeg_g_strfreev (parts);
      D.21895 = 0;
      return D.21895;
      <D.20239>:
      D.21894 = *tmp;
      if (D.21894 != 0B) goto <D.20240>; else goto <D.20241>;
      <D.20241>:
      if (retargetable != 0B) goto <D.21968>; else goto <D.21969>;
      <D.21968>:
      D.21970 = version == 0B;
      D.21971 = culture == 0B;
      D.21972 = D.21970 | D.21971;
      if (D.21972 != 0) goto cleanup_and_fail; else goto <D.21973>;
      <D.21973>:
      D.21974 = key == 0B;
      D.21975 = token == 0B;
      D.21976 = D.21974 & D.21975;
      if (D.21976 != 0) goto cleanup_and_fail; else goto <D.21977>;
      <D.21977>:
      <D.21969>:
      res = build_assembly_name (dllname, version, culture, token, key, flags, arch, aname, save_public_key);
      monoeg_g_strfreev (parts);
      D.21895 = res;
      return D.21895;
      cleanup_and_fail:
      monoeg_g_strfreev (parts);
      D.21895 = 0;
      return D.21895;
    }
  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.21982;
  int eqsign.50;
  gchar * D.21984;
  int D.21985;
  int D.21986;
  unsigned int D.21987;
  unsigned int D.21988;
  unsigned int D.21989;
  const short unsigned int * * D.21991;
  const short unsigned int * D.21992;
  sizetype D.21993;
  gchar * D.21994;
  char D.21995;
  unsigned int D.21996;
  unsigned int D.21997;
  const short unsigned int * D.21998;
  short unsigned int D.21999;
  int D.22000;
  int D.22001;
  gchar * D.22002;
  gchar * D.22003;
  gchar * D.22004;
  char * eqsign;

  eqsign = __builtin_strchr (pair, 61);
  if (eqsign == 0B) goto <D.21980>; else goto <D.21981>;
  <D.21980>:
  *key = 0B;
  *keylen = 0;
  *value = 0B;
  D.21982 = 0;
  return D.21982;
  <D.21981>:
  *key = pair;
  eqsign.50 = (int) eqsign;
  D.21984 = *key;
  D.21985 = (int) D.21984;
  D.21986 = eqsign.50 - D.21985;
  D.21987 = (unsigned int) D.21986;
  *keylen = D.21987;
  goto <D.20213>;
  <D.20212>:
  D.21988 = *keylen;
  D.21989 = D.21988 + 4294967295;
  *keylen = D.21989;
  <D.20213>:
  D.21988 = *keylen;
  if (D.21988 != 0) goto <D.21990>; else goto <D.20214>;
  <D.21990>:
  D.21991 = __ctype_b_loc ();
  D.21992 = *D.21991;
  D.21984 = *key;
  D.21988 = *keylen;
  D.21993 = D.21988 + 4294967295;
  D.21994 = D.21984 + D.21993;
  D.21995 = *D.21994;
  D.21996 = (unsigned int) D.21995;
  D.21997 = D.21996 * 2;
  D.21998 = D.21992 + D.21997;
  D.21999 = *D.21998;
  D.22000 = (int) D.21999;
  D.22001 = D.22000 & 8192;
  if (D.22001 != 0) goto <D.20212>; else goto <D.20214>;
  <D.20214>:
  D.22002 = eqsign + 1;
  D.22003 = monoeg_g_strchomp (D.22002);
  D.22004 = monoeg_g_strchug (D.22003);
  *value = D.22004;
  D.21982 = 1;
  return D.21982;
}


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.51;
  unsigned int D.22009;
  gboolean D.22012;
  int major.52;
  short unsigned int D.22014;
  int minor.53;
  short unsigned int D.22016;
  int build.54;
  short unsigned int D.22020;
  int revision.55;
  short unsigned int D.22025;
  short unsigned int D.22027;
  gchar * D.22028;
  int D.22031;
  gchar * D.22034;
  gchar * D.22036;
  int D.22039;
  unsigned int D.22042;
  mono_byte[17] * D.22045;
  int D.20197;
  int iftmp.56;
  int D.20196;
  const char[5] * D.22053;
  unsigned char D.22054;
  int D.22055;
  unsigned char D.22056;
  int D.22057;
  _Bool D.22058;
  _Bool D.22059;
  _Bool D.22060;
  const unsigned char * D.22063;
  unsigned char D.22064;
  int D.22065;
  const unsigned char * D.22066;
  unsigned char D.22067;
  int D.22068;
  _Bool D.22069;
  _Bool D.22070;
  const unsigned char * D.22073;
  unsigned char D.22074;
  int D.22075;
  const unsigned char * D.22076;
  unsigned char D.22077;
  int D.22078;
  _Bool D.22079;
  _Bool D.22080;
  const unsigned char * D.22083;
  unsigned char D.22084;
  int D.22085;
  const unsigned char * D.22086;
  unsigned char D.22087;
  int D.22088;
  int D.22091;
  int is_ecma.57;
  gchar * pkey.58;
  unsigned int D.22099;
  gchar * pkeyptr.59;
  unsigned int len.60;
  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, 60);
      if (version != 0B) goto <D.22006>; else goto <D.22007>;
      <D.22006>:
      version_parts = sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision);
      version_parts.51 = (unsigned int) version_parts;
      D.22009 = version_parts.51 + 4294967294;
      if (D.22009 > 2) goto <D.22010>; else goto <D.22011>;
      <D.22010>:
      D.22012 = 0;
      return D.22012;
      <D.22011>:
      major.52 = major;
      D.22014 = (short unsigned int) major.52;
      aname->major = D.22014;
      minor.53 = minor;
      D.22016 = (short unsigned int) minor.53;
      aname->minor = D.22016;
      if (version_parts > 2) goto <D.22017>; else goto <D.22018>;
      <D.22017>:
      build.54 = build;
      D.22020 = (short unsigned int) build.54;
      aname->build = D.22020;
      goto <D.22021>;
      <D.22018>:
      aname->build = 0;
      <D.22021>:
      if (version_parts == 4) goto <D.22022>; else goto <D.22023>;
      <D.22022>:
      revision.55 = revision;
      D.22025 = (short unsigned int) revision.55;
      aname->revision = D.22025;
      goto <D.22026>;
      <D.22023>:
      aname->revision = 0;
      <D.22026>:
      <D.22007>:
      aname->flags = flags;
      D.22027 = (short unsigned int) arch;
      aname->arch = D.22027;
      D.22028 = monoeg_strdup (name);
      aname->name = D.22028;
      if (culture != 0B) goto <D.22029>; else goto <D.22030>;
      <D.22029>:
      D.22031 = monoeg_ascii_strcasecmp (culture, "neutral");
      if (D.22031 == 0) goto <D.22032>; else goto <D.22033>;
      <D.22032>:
      D.22034 = monoeg_strdup ("");
      aname->culture = D.22034;
      goto <D.22035>;
      <D.22033>:
      D.22036 = monoeg_strdup (culture);
      aname->culture = D.22036;
      <D.22035>:
      <D.22030>:
      if (token != 0B) goto <D.22037>; else goto <D.22038>;
      <D.22037>:
      D.22039 = strncmp (token, "null", 4);
      if (D.22039 != 0) goto <D.22040>; else goto <D.22041>;
      <D.22040>:
      {
        char * lower;

        D.22042 = strlen (token);
        if (D.22042 != 16) goto <D.22043>; else goto <D.22044>;
        <D.22043>:
        mono_assembly_name_free (aname);
        D.22012 = 0;
        return D.22012;
        <D.22044>:
        lower = monoeg_g_ascii_strdown (token, 17);
        D.22045 = &aname->public_key_token;
        monoeg_g_strlcpy (D.22045, lower, 17);
        monoeg_g_free (lower);
      }
      <D.22041>:
      <D.22038>:
      if (key != 0B) goto <D.22046>; else goto <D.22047>;
      <D.22046>:
      {
        gboolean is_ecma;

        try
          {
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = key;
                D.22053 = "null";
                D.22054 = MEM[(const unsigned char *)D.22053];
                D.22055 = (int) D.22054;
                D.22056 = *__s2;
                D.22057 = (int) D.22056;
                __result = D.22055 - D.22057;
                {
                  D.22058 = __s2_len != 0;
                  D.22059 = __result == 0;
                  D.22060 = D.22058 & D.22059;
                  if (D.22060 != 0) goto <D.22061>; else goto <D.22062>;
                  <D.22061>:
                  D.22063 = &MEM[(void *)"null" + 1B];
                  D.22064 = *D.22063;
                  D.22065 = (int) D.22064;
                  D.22066 = __s2 + 1;
                  D.22067 = *D.22066;
                  D.22068 = (int) D.22067;
                  __result = D.22065 - D.22068;
                  D.22069 = __s2_len > 1;
                  D.22059 = __result == 0;
                  D.22070 = D.22069 & D.22059;
                  if (D.22070 != 0) goto <D.22071>; else goto <D.22072>;
                  <D.22071>:
                  D.22073 = &MEM[(void *)"null" + 2B];
                  D.22074 = *D.22073;
                  D.22075 = (int) D.22074;
                  D.22076 = __s2 + 2;
                  D.22077 = *D.22076;
                  D.22078 = (int) D.22077;
                  __result = D.22075 - D.22078;
                  D.22079 = __s2_len > 2;
                  D.22059 = __result == 0;
                  D.22080 = D.22079 & D.22059;
                  if (D.22080 != 0) goto <D.22081>; else goto <D.22082>;
                  <D.22081>:
                  D.22083 = &MEM[(void *)"null" + 3B];
                  D.22084 = *D.22083;
                  D.22085 = (int) D.22084;
                  D.22086 = __s2 + 3;
                  D.22087 = *D.22086;
                  D.22088 = (int) D.22087;
                  __result = D.22085 - D.22088;
                  <D.22082>:
                  <D.22072>:
                  <D.22062>:
                }
                D.20196 = __result;
              }
              iftmp.56 = -D.20196;
              goto <D.22089>;
              <D.22052>:
              iftmp.56 = __builtin_strcmp (key, "null");
              <D.22089>:
              D.20197 = iftmp.56;
            }
            if (D.20197 == 0) goto <D.22048>; else goto <D.22090>;
            <D.22090>:
            D.22091 = parse_public_key (key, &pkey, &is_ecma);
            if (D.22091 == 0) goto <D.22048>; else goto <D.22049>;
            <D.22048>:
            mono_assembly_name_free (aname);
            D.22012 = 0;
            return D.22012;
            <D.22049>:
            is_ecma.57 = is_ecma;
            if (is_ecma.57 != 0) goto <D.22093>; else goto <D.22094>;
            <D.22093>:
            if (save_public_key != 0) goto <D.22095>; else goto <D.22096>;
            <D.22095>:
            pkey.58 = pkey;
            aname->public_key = pkey.58;
            goto <D.22098>;
            <D.22096>:
            pkey.58 = pkey;
            monoeg_g_free (pkey.58);
            <D.22098>:
            D.22045 = &aname->public_key_token;
            monoeg_g_strlcpy (D.22045, "b77a5c561934e089", 17);
            D.22012 = 1;
            return D.22012;
            <D.22094>:
            pkey.58 = pkey;
            D.22099 = mono_metadata_decode_blob_size (pkey.58, &pkeyptr);
            len = (gint) D.22099;
            pkeyptr.59 = pkeyptr;
            len.60 = (unsigned int) len;
            mono_digest_get_public_token (&tok, pkeyptr.59, len.60);
            encoded = encode_public_tok (&tok, 8);
            D.22045 = &aname->public_key_token;
            monoeg_g_strlcpy (D.22045, encoded, 17);
            monoeg_g_free (encoded);
            if (save_public_key != 0) goto <D.22102>; else goto <D.22103>;
            <D.22102>:
            pkey.58 = pkey;
            aname->public_key = pkey.58;
            goto <D.22104>;
            <D.22103>:
            pkey.58 = pkey;
            monoeg_g_free (pkey.58);
            <D.22104>:
          }
        finally
          {
            is_ecma = {CLOBBER};
          }
      }
      <D.22047>:
      D.22012 = 1;
      return D.22012;
    }
  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)
{
  unsigned int D.22109;
  unsigned int D.22110;
  gboolean D.22113;
  int D.20146;
  int iftmp.61;
  int D.20145;
  const char[33] * D.22117;
  unsigned char D.22118;
  int D.22119;
  unsigned char D.22120;
  int D.22121;
  _Bool D.22122;
  _Bool D.22123;
  _Bool D.22124;
  const unsigned char * D.22127;
  unsigned char D.22128;
  int D.22129;
  const unsigned char * D.22130;
  unsigned char D.22131;
  int D.22132;
  _Bool D.22133;
  _Bool D.22134;
  const unsigned char * D.22137;
  unsigned char D.22138;
  int D.22139;
  const unsigned char * D.22140;
  unsigned char D.22141;
  int D.22142;
  _Bool D.22143;
  _Bool D.22144;
  const unsigned char * D.22147;
  unsigned char D.22148;
  int D.22149;
  const unsigned char * D.22150;
  unsigned char D.22151;
  int D.22152;
  gchar * D.22158;
  char D.22159;
  int D.22160;
  char D.22161;
  const gchar * D.22162;
  char D.22163;
  int D.22164;
  signed char D.22165;
  signed char val.62;
  signed char D.22167;
  int D.22168;
  const gchar * D.22171;
  char D.22172;
  int D.22173;
  const gchar * D.22174;
  char D.22175;
  int D.22176;
  signed char D.22177;
  signed char D.22178;
  unsigned int D.22181;
  unsigned int D.22182;
  int j.63;
  sizetype j.64;
  const gchar * D.22187;
  char D.22188;
  int D.22189;
  char D.22190;
  char D.22191;
  int j.65;
  sizetype j.66;
  const gchar * D.22194;
  char D.22195;
  int D.22196;
  char D.22197;
  signed char D.22198;
  signed char D.22199;
  signed char D.22200;
  char D.22201;
  char D.22204;
  char D.22206;
  char D.22208;
  char D.22210;
  unsigned int D.22212;
  unsigned int D.22213;
  unsigned int D.22214;
  int D.22215;
  int D.22222;
  unsigned int D.22223;
  int offset.67;
  sizetype offset.68;
  gchar * D.22226;
  char D.22227;
  int D.22229;
  unsigned int D.22230;
  int offset.69;
  sizetype offset.70;
  gchar * D.22233;
  int offset.71;
  sizetype offset.72;
  gchar * D.22236;
  sizetype i.73;
  gchar * D.22238;
  int j.74;
  sizetype j.75;
  const gchar * D.22241;
  char D.22242;
  int D.22243;
  char D.22244;
  char D.22245;
  int j.76;
  sizetype j.77;
  const gchar * D.22248;
  char D.22249;
  int D.22250;
  char D.22251;
  signed char D.22252;
  signed char D.22253;
  signed char D.22254;
  char D.22255;
  int D.22256;
  const gchar * pkey;
  gchar header[16];
  gchar val;
  gchar * arr;
  gint i;
  gint j;
  gint offset;
  gint bitlen;
  gint keylen;
  gint pkeylen;

  try
    {
      D.22109 = strlen (key);
      D.22110 = D.22109 >> 1;
      keylen = (gint) D.22110;
      if (keylen <= 0) goto <D.22111>; else goto <D.22112>;
      <D.22111>:
      D.22113 = 0;
      return D.22113;
      <D.22112>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = key;
          D.22117 = "00000000000000000400000000000000";
          D.22118 = MEM[(const unsigned char *)D.22117];
          D.22119 = (int) D.22118;
          D.22120 = *__s2;
          D.22121 = (int) D.22120;
          __result = D.22119 - D.22121;
          {
            D.22122 = __s2_len != 0;
            D.22123 = __result == 0;
            D.22124 = D.22122 & D.22123;
            if (D.22124 != 0) goto <D.22125>; else goto <D.22126>;
            <D.22125>:
            D.22127 = &MEM[(void *)"00000000000000000400000000000000" + 1B];
            D.22128 = *D.22127;
            D.22129 = (int) D.22128;
            D.22130 = __s2 + 1;
            D.22131 = *D.22130;
            D.22132 = (int) D.22131;
            __result = D.22129 - D.22132;
            D.22133 = __s2_len > 1;
            D.22123 = __result == 0;
            D.22134 = D.22133 & D.22123;
            if (D.22134 != 0) goto <D.22135>; else goto <D.22136>;
            <D.22135>:
            D.22137 = &MEM[(void *)"00000000000000000400000000000000" + 2B];
            D.22138 = *D.22137;
            D.22139 = (int) D.22138;
            D.22140 = __s2 + 2;
            D.22141 = *D.22140;
            D.22142 = (int) D.22141;
            __result = D.22139 - D.22142;
            D.22143 = __s2_len > 2;
            D.22123 = __result == 0;
            D.22144 = D.22143 & D.22123;
            if (D.22144 != 0) goto <D.22145>; else goto <D.22146>;
            <D.22145>:
            D.22147 = &MEM[(void *)"00000000000000000400000000000000" + 3B];
            D.22148 = *D.22147;
            D.22149 = (int) D.22148;
            D.22150 = __s2 + 3;
            D.22151 = *D.22150;
            D.22152 = (int) D.22151;
            __result = D.22149 - D.22152;
            <D.22146>:
            <D.22136>:
            <D.22126>:
          }
          D.20145 = __result;
        }
        iftmp.61 = -D.20145;
        goto <D.22153>;
        <D.22116>:
        iftmp.61 = __builtin_strcmp (key, "00000000000000000400000000000000");
        <D.22153>:
        D.20146 = iftmp.61;
      }
      if (D.20146 == 0) goto <D.22154>; else goto <D.22155>;
      <D.22154>:
      if (pubkey != 0B) goto <D.22156>; else goto <D.22157>;
      <D.22156>:
      D.22158 = monoeg_strdup (key);
      *pubkey = D.22158;
      *is_ecma = 1;
      <D.22157>:
      D.22113 = 1;
      return D.22113;
      <D.22155>:
      *is_ecma = 0;
      D.22159 = *key;
      D.22160 = monoeg_g_ascii_xdigit_value (D.22159);
      D.22161 = (char) D.22160;
      val = D.22161 << 4;
      D.22162 = key + 1;
      D.22163 = *D.22162;
      D.22164 = monoeg_g_ascii_xdigit_value (D.22163);
      D.22165 = (signed char) D.22164;
      val.62 = (signed char) val;
      D.22167 = D.22165 | val.62;
      val = (gchar) D.22167;
      D.22168 = (int) val;
      switch (D.22168) <default: <D.20150>, case 0: <D.20147>, case 6: <D.20149>>
      <D.20147>:
      if (keylen <= 12) goto <D.22169>; else goto <D.22170>;
      <D.22169>:
      D.22113 = 0;
      return D.22113;
      <D.22170>:
      D.22171 = key + 24;
      D.22172 = *D.22171;
      D.22173 = monoeg_g_ascii_xdigit_value (D.22172);
      val = (gchar) D.22173;
      D.22174 = key + 25;
      D.22175 = *D.22174;
      D.22176 = monoeg_g_ascii_xdigit_value (D.22175);
      D.22177 = (signed char) D.22176;
      val.62 = (signed char) val;
      D.22178 = D.22177 | val.62;
      val = (gchar) D.22178;
      if (val != 6) goto <D.22179>; else goto <D.22180>;
      <D.22179>:
      D.22113 = 0;
      return D.22113;
      <D.22180>:
      pkey = key + 24;
      goto <D.20148>;
      <D.20149>:
      pkey = key;
      goto <D.20148>;
      <D.20150>:
      D.22113 = 0;
      return D.22113;
      <D.20148>:
      D.22181 = strlen (pkey);
      D.22182 = D.22181 >> 1;
      pkeylen = (gint) D.22182;
      if (pkeylen <= 15) goto <D.22183>; else goto <D.22184>;
      <D.22183>:
      D.22113 = 0;
      return D.22113;
      <D.22184>:
      i = 0;
      j = 0;
      goto <D.20152>;
      <D.20151>:
      j.63 = j;
      j = j.63 + 1;
      j.64 = (sizetype) j.63;
      D.22187 = pkey + j.64;
      D.22188 = *D.22187;
      D.22189 = monoeg_g_ascii_xdigit_value (D.22188);
      D.22190 = (char) D.22189;
      D.22191 = D.22190 << 4;
      header[i] = D.22191;
      j.65 = j;
      j = j.65 + 1;
      j.66 = (sizetype) j.65;
      D.22194 = pkey + j.66;
      D.22195 = *D.22194;
      D.22196 = monoeg_g_ascii_xdigit_value (D.22195);
      D.22197 = header[i];
      D.22198 = (signed char) D.22197;
      D.22199 = (signed char) D.22196;
      D.22200 = D.22198 | D.22199;
      D.22201 = (char) D.22200;
      header[i] = D.22201;
      i = i + 1;
      <D.20152>:
      if (i <= 15) goto <D.20151>; else goto <D.20153>;
      <D.20153>:
      D.22204 = header[0];
      if (D.22204 != 6) goto <D.22202>; else goto <D.22205>;
      <D.22205>:
      D.22206 = header[1];
      if (D.22206 != 2) goto <D.22202>; else goto <D.22207>;
      <D.22207>:
      D.22208 = header[2];
      if (D.22208 != 0) goto <D.22202>; else goto <D.22209>;
      <D.22209>:
      D.22210 = header[3];
      if (D.22210 != 0) goto <D.22202>; else goto <D.22211>;
      <D.22211>:
      D.22212 = mono_read32 (&MEM[(void *)&header + 8B]);
      if (D.22212 != 826364754) goto <D.22202>; else goto <D.22203>;
      <D.22202>:
      D.22113 = 0;
      return D.22113;
      <D.22203>:
      D.22213 = mono_read32 (&MEM[(void *)&header + 12B]);
      D.22214 = D.22213 >> 3;
      bitlen = (gint) D.22214;
      D.22215 = bitlen + 20;
      if (D.22215 != pkeylen) goto <D.22216>; else goto <D.22217>;
      <D.22216>:
      D.22113 = 0;
      return D.22113;
      <D.22217>:
      if (pubkey == 0B) goto <D.22218>; else goto <D.22219>;
      <D.22218>:
      D.22113 = 1;
      return D.22113;
      <D.22219>:
      offset = 0;
      if (keylen <= 127) goto <D.22220>; else goto <D.22221>;
      <D.22220>:
      D.22222 = keylen + 1;
      D.22223 = (unsigned int) D.22222;
      arr = monoeg_malloc (D.22223);
      offset.67 = offset;
      offset = offset.67 + 1;
      offset.68 = (sizetype) offset.67;
      D.22226 = arr + offset.68;
      D.22227 = (char) keylen;
      *D.22226 = D.22227;
      goto <D.22228>;
      <D.22221>:
      D.22229 = keylen + 2;
      D.22230 = (unsigned int) D.22229;
      arr = monoeg_malloc (D.22230);
      offset.69 = offset;
      offset = offset.69 + 1;
      offset.70 = (sizetype) offset.69;
      D.22233 = arr + offset.70;
      *D.22233 = 128;
      offset.71 = offset;
      offset = offset.71 + 1;
      offset.72 = (sizetype) offset.71;
      D.22236 = arr + offset.72;
      D.22227 = (char) keylen;
      *D.22236 = D.22227;
      <D.22228>:
      i = offset;
      j = 0;
      goto <D.20155>;
      <D.20154>:
      i.73 = (sizetype) i;
      D.22238 = arr + i.73;
      j.74 = j;
      j = j.74 + 1;
      j.75 = (sizetype) j.74;
      D.22241 = key + j.75;
      D.22242 = *D.22241;
      D.22243 = monoeg_g_ascii_xdigit_value (D.22242);
      D.22244 = (char) D.22243;
      D.22245 = D.22244 << 4;
      *D.22238 = D.22245;
      j.76 = j;
      j = j.76 + 1;
      j.77 = (sizetype) j.76;
      D.22248 = key + j.77;
      D.22249 = *D.22248;
      D.22250 = monoeg_g_ascii_xdigit_value (D.22249);
      i.73 = (sizetype) i;
      D.22238 = arr + i.73;
      i.73 = (sizetype) i;
      D.22238 = arr + i.73;
      D.22251 = *D.22238;
      D.22252 = (signed char) D.22251;
      D.22253 = (signed char) D.22250;
      D.22254 = D.22252 | D.22253;
      D.22255 = (char) D.22254;
      *D.22238 = D.22255;
      i = i + 1;
      <D.20155>:
      D.22256 = keylen + offset;
      if (D.22256 > i) goto <D.20154>; else goto <D.20156>;
      <D.20156>:
      *pubkey = arr;
      D.22113 = 1;
      return D.22113;
    }
  finally
    {
      header = {CLOBBER};
    }
}


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

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


mono_assembly_name_new (const char * name)
{
  int D.22261;
  struct MonoAssemblyName * D.22264;
  struct MonoAssemblyName * aname;

  aname = monoeg_malloc0 (60);
  D.22261 = mono_assembly_name_parse (name, aname);
  if (D.22261 != 0) goto <D.22262>; else goto <D.22263>;
  <D.22262>:
  D.22264 = aname;
  return D.22264;
  <D.22263>:
  monoeg_g_free (aname);
  D.22264 = 0B;
  return D.22264;
}


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

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


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

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


mono_assembly_name_get_pubkeytoken (struct MonoAssemblyName * aname)
{
  unsigned char D.22270;
  mono_byte * D.22273;

  D.22270 = aname->public_key_token[0];
  if (D.22270 != 0) goto <D.22271>; else goto <D.22272>;
  <D.22271>:
  D.22273 = &aname->public_key_token;
  return D.22273;
  <D.22272>:
  D.22273 = 0B;
  return D.22273;
}


mono_assembly_name_get_version (struct MonoAssemblyName * aname, uint16_t * minor, uint16_t * build, uint16_t * revision)
{
  short unsigned int D.22277;
  short unsigned int D.22280;
  short unsigned int D.22283;
  uint16_t D.22284;

  if (minor != 0B) goto <D.22275>; else goto <D.22276>;
  <D.22275>:
  D.22277 = aname->minor;
  *minor = D.22277;
  <D.22276>:
  if (build != 0B) goto <D.22278>; else goto <D.22279>;
  <D.22278>:
  D.22280 = aname->build;
  *build = D.22280;
  <D.22279>:
  if (revision != 0B) goto <D.22281>; else goto <D.22282>;
  <D.22281>:
  D.22283 = aname->revision;
  *revision = D.22283;
  <D.22282>:
  D.22284 = aname->major;
  return D.22284;
}


mono_assembly_load_with_partial_name (const char * name, MonoImageOpenStatus * status)
{
  int D.22286;
  struct MonoAssembly * D.22289;
  short unsigned int D.22290;
  short unsigned int D.22291;
  short unsigned int D.22292;
  short unsigned int D.22293;
  short unsigned int D.22294;
  short unsigned int D.22295;
  short unsigned int D.22296;
  char * * assemblies_path.78;
  const char * D.22304;
  char * * extra_gac_paths.79;
  gchar * D.22308;
  const char * D.22312;
  struct MonoString * D.22316;
  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, 60);
      aname = &base_name;
      D.22286 = mono_assembly_name_parse (name, aname);
      if (D.22286 == 0) goto <D.22287>; else goto <D.22288>;
      <D.22287>:
      D.22289 = 0B;
      return D.22289;
      <D.22288>:
      D.22290 = aname->major;
      D.22291 = aname->minor;
      D.22292 = D.22290 | D.22291;
      D.22293 = aname->build;
      D.22294 = D.22292 | D.22293;
      D.22295 = aname->revision;
      D.22296 = D.22294 | D.22295;
      if (D.22296 == 0) goto <D.22297>; else goto <D.22298>;
      <D.22297>:
      aname = mono_assembly_remap_version (aname, &mapped_aname);
      <D.22298>:
      res = mono_assembly_loaded (aname);
      if (res != 0B) goto <D.22299>; else goto <D.22300>;
      <D.22299>:
      mono_assembly_name_free (aname);
      D.22289 = res;
      return D.22289;
      <D.22300>:
      assemblies_path.78 = assemblies_path;
      res = invoke_assembly_preload_hook (aname, assemblies_path.78);
      if (res != 0B) goto <D.22302>; else goto <D.22303>;
      <D.22302>:
      res->in_gac = 0;
      mono_assembly_name_free (aname);
      D.22289 = res;
      return D.22289;
      <D.22303>:
      D.22304 = aname->name;
      fullname = monoeg_g_strdup_printf ("%s.dll", D.22304);
      extra_gac_paths.79 = extra_gac_paths;
      if (extra_gac_paths.79 != 0B) goto <D.22306>; else goto <D.22307>;
      <D.22306>:
      paths = extra_gac_paths;
      goto <D.20306>;
      <D.20305>:
      D.22308 = *paths;
      D.22304 = aname->name;
      gacpath = monoeg_g_build_path ("/", D.22308, "lib", "mono", "gac", D.22304, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      paths = paths + 4;
      <D.20306>:
      if (res == 0B) goto <D.22309>; else goto <D.20307>;
      <D.22309>:
      D.22308 = *paths;
      if (D.22308 != 0B) goto <D.20305>; else goto <D.20307>;
      <D.20307>:
      <D.22307>:
      if (res != 0B) goto <D.22310>; else goto <D.22311>;
      <D.22310>:
      res->in_gac = 1;
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.22289 = res;
      return D.22289;
      <D.22311>:
      D.22312 = mono_assembly_getrootdir ();
      D.22304 = aname->name;
      gacpath = monoeg_g_build_path ("/", D.22312, "mono", "gac", D.22304, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      if (res != 0B) goto <D.22313>; else goto <D.22314>;
      <D.22313>:
      res->in_gac = 1;
      goto <D.22315>;
      <D.22314>:
      {
        struct MonoDomain * domain;
        struct MonoReflectionAssembly * refasm;

        domain = mono_domain_get ();
        D.22316 = mono_string_new (domain, name);
        refasm = mono_try_assembly_resolve (domain, D.22316, 0);
        if (refasm != 0B) goto <D.22317>; else goto <D.22318>;
        <D.22317>:
        res = refasm->assembly;
        <D.22318>:
      }
      <D.22315>:
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.22289 = res;
      return D.22289;
    }
  finally
    {
      base_name = {CLOBBER};
      mapped_aname = {CLOBBER};
    }
}


mono_assembly_remap_version (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_aname)
{
  const char * D.22321;
  struct MonoAssemblyName * D.22324;
  unsigned int D.22325;
  unsigned int D.22326;
  short unsigned int D.22329;
  short unsigned int D.22330;
  short unsigned int D.22331;
  short unsigned int D.22332;
  unsigned int D.22333;
  unsigned int D.22334;
  int D.19808;
  int iftmp.80;
  int D.19807;
  const char[11] * D.22338;
  unsigned char D.22339;
  int D.22340;
  unsigned char D.22341;
  int D.22342;
  _Bool D.22343;
  _Bool D.22344;
  _Bool D.22345;
  const unsigned char * D.22348;
  unsigned char D.22349;
  int D.22350;
  const unsigned char * D.22351;
  unsigned char D.22352;
  int D.22353;
  _Bool D.22354;
  _Bool D.22355;
  const unsigned char * D.22358;
  unsigned char D.22359;
  int D.22360;
  const unsigned char * D.22361;
  unsigned char D.22362;
  int D.22363;
  _Bool D.22364;
  _Bool D.22365;
  const unsigned char * D.22368;
  unsigned char D.22369;
  int D.22370;
  const unsigned char * D.22371;
  unsigned char D.22372;
  int D.22373;
  gchar * D.22377;
  short unsigned int D.22378;
  int D.22379;
  short unsigned int D.22380;
  int D.22381;
  short unsigned int D.22382;
  int D.22383;
  short unsigned int D.22384;
  int D.22385;
  const char * D.22386;
  int D.22387;
  int D.22388;
  int D.22389;
  int D.22390;
  int D.22391;
  int D.22392;
  int res.81;
  const char * D.22393;
  unsigned char D.22396;
  unsigned int index.82;
  _Bool D.22398;
  long int D.22399;
  long int D.22400;
  short unsigned int D.22403;
  short unsigned int D.22406;
  short unsigned int D.22409;
  short unsigned int D.22412;
  short unsigned int D.22415;
  short unsigned int D.22416;
  short unsigned int D.22417;
  int D.22420;
  int D.22421;
  int D.22422;
  int D.22423;
  const struct MonoRuntimeInfo * current_runtime;
  int pos;
  int first;
  int last;

  D.22321 = aname->name;
  if (D.22321 == 0B) goto <D.22322>; else goto <D.22323>;
  <D.22322>:
  D.22324 = aname;
  return D.22324;
  <D.22323>:
  current_runtime = mono_get_runtime_info ();
  D.22325 = aname->flags;
  D.22326 = D.22325 & 256;
  if (D.22326 != 0) goto <D.22327>; else goto <D.22328>;
  <D.22327>:
  {
    const struct AssemblyVersionSet * vset;

    vset = &current_runtime->version_sets[0];
    memcpy (dest_aname, aname, 60);
    D.22329 = vset->major;
    dest_aname->major = D.22329;
    D.22330 = vset->minor;
    dest_aname->minor = D.22330;
    D.22331 = vset->build;
    dest_aname->build = D.22331;
    D.22332 = vset->revision;
    dest_aname->revision = D.22332;
    D.22333 = dest_aname->flags;
    D.22334 = D.22333 & 4294967039;
    dest_aname->flags = D.22334;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = aname->name;
        D.22338 = "System.Net";
        D.22339 = MEM[(const unsigned char *)D.22338];
        D.22340 = (int) D.22339;
        D.22341 = *__s2;
        D.22342 = (int) D.22341;
        __result = D.22340 - D.22342;
        {
          D.22343 = __s2_len != 0;
          D.22344 = __result == 0;
          D.22345 = D.22343 & D.22344;
          if (D.22345 != 0) goto <D.22346>; else goto <D.22347>;
          <D.22346>:
          D.22348 = &MEM[(void *)"System.Net" + 1B];
          D.22349 = *D.22348;
          D.22350 = (int) D.22349;
          D.22351 = __s2 + 1;
          D.22352 = *D.22351;
          D.22353 = (int) D.22352;
          __result = D.22350 - D.22353;
          D.22354 = __s2_len > 1;
          D.22344 = __result == 0;
          D.22355 = D.22354 & D.22344;
          if (D.22355 != 0) goto <D.22356>; else goto <D.22357>;
          <D.22356>:
          D.22358 = &MEM[(void *)"System.Net" + 2B];
          D.22359 = *D.22358;
          D.22360 = (int) D.22359;
          D.22361 = __s2 + 2;
          D.22362 = *D.22361;
          D.22363 = (int) D.22362;
          __result = D.22360 - D.22363;
          D.22364 = __s2_len > 2;
          D.22344 = __result == 0;
          D.22365 = D.22364 & D.22344;
          if (D.22365 != 0) goto <D.22366>; else goto <D.22367>;
          <D.22366>:
          D.22368 = &MEM[(void *)"System.Net" + 3B];
          D.22369 = *D.22368;
          D.22370 = (int) D.22369;
          D.22371 = __s2 + 3;
          D.22372 = *D.22371;
          D.22373 = (int) D.22372;
          __result = D.22370 - D.22373;
          <D.22367>:
          <D.22357>:
          <D.22347>:
        }
        D.19807 = __result;
      }
      iftmp.80 = -D.19807;
      goto <D.22374>;
      <D.22337>:
      D.22321 = aname->name;
      iftmp.80 = __builtin_strcmp (D.22321, "System.Net");
      <D.22374>:
      D.19808 = iftmp.80;
    }
    if (D.19808 == 0) goto <D.22375>; else goto <D.22376>;
    <D.22375>:
    D.22377 = monoeg_strdup ("System");
    dest_aname->name = D.22377;
    <D.22376>:
    remap_keys (dest_aname);
    D.22321 = aname->name;
    D.22378 = aname->major;
    D.22379 = (int) D.22378;
    D.22380 = aname->minor;
    D.22381 = (int) D.22380;
    D.22382 = aname->build;
    D.22383 = (int) D.22382;
    D.22384 = aname->revision;
    D.22385 = (int) D.22384;
    D.22386 = dest_aname->name;
    D.22329 = vset->major;
    D.22387 = (int) D.22329;
    D.22330 = vset->minor;
    D.22388 = (int) D.22330;
    D.22331 = vset->build;
    D.22389 = (int) D.22331;
    D.22332 = vset->revision;
    D.22390 = (int) D.22332;
    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.22321, D.22379, D.22381, D.22383, D.22385, D.22386, D.22387, D.22388, D.22389, D.22390);
    D.22324 = dest_aname;
    return D.22324;
  }
  <D.22328>:
  first = 0;
  last = 62;
  goto <D.19822>;
  <D.19821>:
  {
    int res;

    D.22391 = last - first;
    D.22392 = D.22391 / 2;
    pos = D.22392 + first;
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22321 = aname->name;
      D.22393 = framework_assemblies[pos].assembly_name;
      res.81 = __builtin_strcmp (D.22321, D.22393);
    }
    res = res.81;
    if (res == 0) goto <D.22394>; else goto <D.22395>;
    <D.22394>:
    {
      const struct AssemblyVersionSet * vset;
      int index;

      D.22396 = framework_assemblies[pos].version_set_index;
      index = (int) D.22396;
      index.82 = (unsigned int) index;
      D.22398 = index.82 > 3;
      D.22399 = (long int) D.22398;
      D.22400 = __builtin_expect (D.22399, 0);
      if (D.22400 != 0) goto <D.22401>; else goto <D.22402>;
      <D.22401>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 995, "index < G_N_ELEMENTS (current_runtime->version_sets)");
      <D.22402>:
      vset = &current_runtime->version_sets[index];
      D.22378 = aname->major;
      D.22403 = vset->major;
      if (D.22378 == D.22403) goto <D.22404>; else goto <D.22405>;
      <D.22404>:
      D.22380 = aname->minor;
      D.22406 = vset->minor;
      if (D.22380 == D.22406) goto <D.22407>; else goto <D.22408>;
      <D.22407>:
      D.22382 = aname->build;
      D.22409 = vset->build;
      if (D.22382 == D.22409) goto <D.22410>; else goto <D.22411>;
      <D.22410>:
      D.22384 = aname->revision;
      D.22412 = vset->revision;
      if (D.22384 == D.22412) goto <D.22413>; else goto <D.22414>;
      <D.22413>:
      D.22324 = aname;
      return D.22324;
      <D.22414>:
      <D.22411>:
      <D.22408>:
      <D.22405>:
      D.22378 = aname->major;
      D.22380 = aname->minor;
      D.22415 = D.22378 | D.22380;
      D.22382 = aname->build;
      D.22416 = D.22415 | D.22382;
      D.22384 = aname->revision;
      D.22417 = D.22416 | D.22384;
      if (D.22417 != 0) goto <D.22418>; else goto <D.22419>;
      <D.22418>:
      D.22321 = aname->name;
      D.22378 = aname->major;
      D.22379 = (int) D.22378;
      D.22380 = aname->minor;
      D.22381 = (int) D.22380;
      D.22382 = aname->build;
      D.22383 = (int) D.22382;
      D.22384 = aname->revision;
      D.22385 = (int) D.22384;
      D.22403 = vset->major;
      D.22420 = (int) D.22403;
      D.22406 = vset->minor;
      D.22421 = (int) D.22406;
      D.22409 = vset->build;
      D.22422 = (int) D.22409;
      D.22412 = vset->revision;
      D.22423 = (int) D.22412;
      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.22321, D.22379, D.22381, D.22383, D.22385, D.22420, D.22421, D.22422, D.22423);
      <D.22419>:
      memcpy (dest_aname, aname, 60);
      D.22403 = vset->major;
      dest_aname->major = D.22403;
      D.22406 = vset->minor;
      dest_aname->minor = D.22406;
      D.22409 = vset->build;
      dest_aname->build = D.22409;
      D.22412 = vset->revision;
      dest_aname->revision = D.22412;
      D.22324 = dest_aname;
      return D.22324;
    }
    <D.22395>:
    if (res < 0) goto <D.22424>; else goto <D.22425>;
    <D.22424>:
    last = pos + -1;
    goto <D.22426>;
    <D.22425>:
    first = pos + 1;
    <D.22426>:
  }
  <D.19822>:
  if (first <= last) goto <D.19821>; else goto <D.19823>;
  <D.19823>:
  D.22324 = aname;
  return D.22324;
}


remap_keys (struct MonoAssemblyName * aname)
{
  int D.19786;
  const char * D.22430;
  const char * D.22431;
  mono_byte[17] * D.22433;
  const char * D.22434;
  int D.22435;
  const char * D.22436;
  unsigned int i.83;
  int i;

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

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

      D.22430 = aname->name;
      D.22431 = entry->name;
      D.19786 = __builtin_strcmp (D.22430, D.22431);
    }
    if (D.19786 != 0) goto <D.22428>; else goto <D.22432>;
    <D.22432>:
    D.22433 = &aname->public_key_token;
    D.22434 = entry->from;
    D.22435 = mono_public_tokens_are_equal (D.22433, D.22434);
    if (D.22435 == 0) goto <D.22428>; else goto <D.22429>;
    <D.22428>:
    // predicted unlikely by continue predictor.
    goto <D.19787>;
    <D.22429>:
    D.22433 = &aname->public_key_token;
    D.22436 = entry->to;
    memcpy (D.22433, D.22436, 17);
    D.22430 = aname->name;
    D.22434 = entry->from;
    D.22436 = entry->to;
    mono_trace (64, 1, "Remapped public key token of retargetable assembly %s from %s to %s", D.22430, D.22434, D.22436);
    return;
  }
  <D.19787>:
  i = i + 1;
  <D.19789>:
  i.83 = (unsigned int) i;
  if (i.83 <= 13) goto <D.19788>; else goto <D.19790>;
  <D.19790>:
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.22439;
  unsigned int D.22440;

  D.22440 = __builtin_object_size (__dest, 0);
  D.22439 = __builtin___memcpy_chk (__dest, __src, __len, D.22440);
  return D.22439;
}


invoke_assembly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<T1920>) (struct MonoAssemblyName *, char * *, void *) D.22442;
  void * D.22443;
  struct MonoAssembly * D.22446;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_preload_hook;
  goto <D.19951>;
  <D.19950>:
  D.22442 = hook->func;
  D.22443 = hook->user_data;
  assembly = D.22442 (aname, assemblies_path, D.22443);
  if (assembly != 0B) goto <D.22444>; else goto <D.22445>;
  <D.22444>:
  D.22446 = assembly;
  return D.22446;
  <D.22445>:
  hook = hook->next;
  <D.19951>:
  if (hook != 0B) goto <D.19950>; else goto <D.19952>;
  <D.19952>:
  D.22446 = 0B;
  return D.22446;
}


probe_for_partial_name (const char * basepath, const char * fullname, struct MonoAssemblyName * aname, MonoImageOpenStatus * status)
{
  struct MonoAssembly * D.22450;
  short unsigned int D.22451;
  short unsigned int D.22452;
  short unsigned int D.22453;
  short unsigned int D.22454;
  short unsigned int D.22455;
  short unsigned int D.22456;
  short unsigned int D.22457;
  _Bool D.22458;
  const char * D.22459;
  int D.22460;
  const char * D.22463;
  int D.20290;
  const char * D.22466;
  mono_byte[17] * D.22471;
  char D.22472;
  int D.22475;
  int iftmp.84;
  unsigned int D.22485;
  unsigned int D.22486;
  unsigned int D.22487;
  unsigned int D.22488;
  unsigned int D.22490;
  unsigned int D.22491;
  unsigned int D.22492;
  unsigned int D.22493;
  short unsigned int D.22496;
  int D.22497;
  short unsigned int D.22503;
  int D.22504;
  short unsigned int D.22510;
  int D.22511;
  short unsigned int D.22517;
  int D.22518;
  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.22448>; else goto <D.22449>;
      <D.22448>:
      D.22450 = 0B;
      return D.22450;
      <D.22449>:
      D.22451 = aname->major;
      D.22452 = aname->minor;
      D.22453 = D.22451 | D.22452;
      D.22454 = aname->build;
      D.22455 = D.22453 | D.22454;
      D.22456 = aname->revision;
      D.22457 = D.22455 | D.22456;
      D.22458 = D.22457 != 0;
      exact_version = (gboolean) D.22458;
      goto <D.20281>;
      <D.20291>:
      {
        gboolean match;

        match = 1;
        D.22459 = aname->name;
        D.22460 = parse_assembly_directory_name (D.22459, direntry, &gac_aname);
        if (D.22460 == 0) goto <D.22461>; else goto <D.22462>;
        <D.22461>:
        // predicted unlikely by continue predictor.
        goto <D.20281>;
        <D.22462>:
        D.22463 = aname->culture;
        if (D.22463 != 0B) goto <D.22464>; else goto <D.22465>;
        <D.22464>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.22463 = aname->culture;
          D.22466 = gac_aname.culture;
          D.20290 = __builtin_strcmp (D.22463, D.22466);
        }
        if (D.20290 != 0) goto <D.22467>; else goto <D.22468>;
        <D.22467>:
        match = 0;
        <D.22468>:
        <D.22465>:
        if (match != 0) goto <D.22469>; else goto <D.22470>;
        <D.22469>:
        D.22471 = &aname->public_key_token;
        D.22472 = MEM[(const char *)D.22471];
        if (D.22472 != 0) goto <D.22473>; else goto <D.22474>;
        <D.22473>:
        D.22471 = &aname->public_key_token;
        D.22475 = mono_public_tokens_are_equal (D.22471, &gac_aname.public_key_token);
        if (D.22475 == 0) goto <D.22476>; else goto <D.22477>;
        <D.22476>:
        match = 0;
        <D.22477>:
        <D.22474>:
        <D.22470>:
        if (match != 0) goto <D.22478>; else goto <D.22479>;
        <D.22478>:
        if (exact_version != 0) goto <D.22480>; else goto <D.22481>;
        <D.22480>:
        D.22485 = BIT_FIELD_REF <*aname, 32, 384>;
        D.22486 = D.22485;
        D.22487 = BIT_FIELD_REF <gac_aname, 32, 384>;
        D.22488 = D.22487;
        if (D.22486 == D.22488) goto <D.22489>; else goto <D.22483>;
        <D.22489>:
        D.22490 = BIT_FIELD_REF <*aname, 32, 416>;
        D.22491 = D.22490;
        D.22492 = BIT_FIELD_REF <gac_aname, 32, 416>;
        D.22493 = D.22492;
        if (D.22491 == D.22493) goto <D.22494>; else goto <D.22483>;
        <D.22494>:
        iftmp.84 = 1;
        goto <D.22484>;
        <D.22483>:
        iftmp.84 = 0;
        <D.22484>:
        match = iftmp.84;
        goto <D.22495>;
        <D.22481>:
        D.22496 = gac_aname.major;
        D.22497 = (int) D.22496;
        if (D.22497 < major) goto <D.22498>; else goto <D.22499>;
        <D.22498>:
        match = 0;
        goto <D.22500>;
        <D.22499>:
        D.22496 = gac_aname.major;
        D.22497 = (int) D.22496;
        if (D.22497 == major) goto <D.22501>; else goto <D.22502>;
        <D.22501>:
        D.22503 = gac_aname.minor;
        D.22504 = (int) D.22503;
        if (D.22504 < minor) goto <D.22505>; else goto <D.22506>;
        <D.22505>:
        match = 0;
        goto <D.22507>;
        <D.22506>:
        D.22503 = gac_aname.minor;
        D.22504 = (int) D.22503;
        if (D.22504 == minor) goto <D.22508>; else goto <D.22509>;
        <D.22508>:
        D.22510 = gac_aname.build;
        D.22511 = (int) D.22510;
        if (D.22511 < build) goto <D.22512>; else goto <D.22513>;
        <D.22512>:
        match = 0;
        goto <D.22514>;
        <D.22513>:
        D.22510 = gac_aname.build;
        D.22511 = (int) D.22510;
        if (D.22511 == build) goto <D.22515>; else goto <D.22516>;
        <D.22515>:
        D.22517 = gac_aname.revision;
        D.22518 = (int) D.22517;
        if (D.22518 <= revision) goto <D.22519>; else goto <D.22520>;
        <D.22519>:
        match = 0;
        <D.22520>:
        <D.22516>:
        <D.22514>:
        <D.22509>:
        <D.22507>:
        <D.22502>:
        <D.22500>:
        <D.22495>:
        <D.22479>:
        if (match != 0) goto <D.22521>; else goto <D.22522>;
        <D.22521>:
        D.22496 = gac_aname.major;
        major = (gint) D.22496;
        D.22503 = gac_aname.minor;
        minor = (gint) D.22503;
        D.22510 = gac_aname.build;
        build = (gint) D.22510;
        D.22517 = gac_aname.revision;
        revision = (gint) D.22517;
        monoeg_g_free (fullpath);
        fullpath = monoeg_g_build_path ("/", basepath, direntry, fullname, 0B);
        <D.22522>:
        mono_assembly_name_free (&gac_aname);
      }
      <D.20281>:
      direntry = monoeg_g_dir_read_name (dirhandle);
      if (direntry != 0B) goto <D.20291>; else goto <D.20292>;
      <D.20292>:
      monoeg_g_dir_close (dirhandle);
      if (fullpath == 0B) goto <D.22523>; else goto <D.22524>;
      <D.22523>:
      D.22450 = 0B;
      return D.22450;
      <D.22524>:
      {
        struct MonoAssembly * res;

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


parse_assembly_directory_name (const char * name, const char * dirname, struct MonoAssemblyName * aname)
{
  gchar * D.22530;
  gchar * * D.22532;
  gchar * D.22533;
  gchar * * D.22535;
  gchar * D.22536;
  gboolean D.22537;
  gchar * * parts;
  gboolean res;

  parts = monoeg_g_strsplit (dirname, "_", 3);
  if (parts == 0B) goto <D.22527>; else goto <D.22529>;
  <D.22529>:
  D.22530 = *parts;
  if (D.22530 == 0B) goto <D.22527>; else goto <D.22531>;
  <D.22531>:
  D.22532 = parts + 4;
  D.22533 = *D.22532;
  if (D.22533 == 0B) goto <D.22527>; else goto <D.22534>;
  <D.22534>:
  D.22535 = parts + 8;
  D.22536 = *D.22535;
  if (D.22536 == 0B) goto <D.22527>; else goto <D.22528>;
  <D.22527>:
  monoeg_g_strfreev (parts);
  D.22537 = 0;
  return D.22537;
  <D.22528>:
  D.22530 = *parts;
  D.22532 = parts + 4;
  D.22533 = *D.22532;
  D.22535 = parts + 8;
  D.22536 = *D.22535;
  res = build_assembly_name (name, D.22530, D.22533, D.22536, 0B, 0, 0, aname, 0);
  monoeg_g_strfreev (parts);
  D.22537 = res;
  return D.22537;
}


mono_assembly_load_corlib (const struct MonoRuntimeInfo * runtime, MonoImageOpenStatus * status)
{
  struct MonoAssembly * corlib.85;
  struct MonoAssembly * D.22542;
  char * * assemblies_path.86;
  struct MonoAssembly * corlib.87;
  struct MonoAssembly * corlib.88;
  const char[4] * D.22552;
  struct MonoAssembly * corlib.89;
  struct MonoAssembly * corlib.90;
  int D.20495;
  int iftmp.91;
  int D.20494;
  const char[4] * D.22564;
  unsigned char D.22565;
  int D.22566;
  unsigned char D.22567;
  int D.22568;
  _Bool D.22569;
  _Bool D.22570;
  _Bool D.22571;
  const unsigned char * D.22574;
  unsigned char D.22575;
  int D.22576;
  const unsigned char * D.22577;
  unsigned char D.22578;
  int D.22579;
  _Bool D.22580;
  _Bool D.22581;
  const unsigned char * D.22584;
  unsigned char D.22585;
  int D.22586;
  const unsigned char * D.22587;
  unsigned char D.22588;
  int D.22589;
  _Bool D.22590;
  _Bool D.22591;
  const unsigned char * D.22594;
  unsigned char D.22595;
  int D.22596;
  const unsigned char * D.22597;
  unsigned char D.22598;
  int D.22599;
  const char * D.22603;
  gchar * D.22604;
  char * corlib_file;
  struct MonoAssemblyName * aname;

  corlib.85 = corlib;
  if (corlib.85 != 0B) goto <D.22540>; else goto <D.22541>;
  <D.22540>:
  D.22542 = corlib;
  return D.22542;
  <D.22541>:
  aname = mono_assembly_name_new ("mscorlib.dll");
  assemblies_path.86 = assemblies_path;
  corlib.87 = invoke_assembly_preload_hook (aname, assemblies_path.86);
  corlib = corlib.87;
  mono_assembly_name_free (aname);
  monoeg_g_free (aname);
  corlib.85 = corlib;
  if (corlib.85 != 0B) goto <D.22545>; else goto <D.22546>;
  <D.22545>:
  D.22542 = corlib;
  return D.22542;
  <D.22546>:
  assemblies_path.86 = assemblies_path;
  if (assemblies_path.86 != 0B) goto <D.22547>; else goto <D.22548>;
  <D.22547>:
  assemblies_path.86 = assemblies_path;
  corlib.88 = load_in_path ("mscorlib.dll", assemblies_path.86, status, 0);
  corlib = corlib.88;
  corlib.85 = corlib;
  if (corlib.85 != 0B) goto <D.22550>; else goto <D.22551>;
  <D.22550>:
  D.22542 = corlib;
  return D.22542;
  <D.22551>:
  <D.22548>:
  D.22552 = &runtime->framework_version;
  corlib_file = monoeg_g_build_path ("/", "mono", D.22552, "mscorlib.dll", 0B);
  assemblies_path.86 = assemblies_path;
  if (assemblies_path.86 != 0B) goto <D.22553>; else goto <D.22554>;
  <D.22553>:
  assemblies_path.86 = assemblies_path;
  corlib.89 = load_in_path (corlib_file, assemblies_path.86, status, 0);
  corlib = corlib.89;
  corlib.85 = corlib;
  if (corlib.85 != 0B) goto <D.22556>; else goto <D.22557>;
  <D.22556>:
  monoeg_g_free (corlib_file);
  D.22542 = corlib;
  return D.22542;
  <D.22557>:
  <D.22554>:
  corlib.90 = load_in_path (corlib_file, &default_path, status, 0);
  corlib = corlib.90;
  monoeg_g_free (corlib_file);
  corlib.85 = corlib;
  if (corlib.85 != 0B) goto <D.22559>; else goto <D.22560>;
  <D.22559>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = &runtime->framework_version;
      D.22564 = "4.5";
      D.22565 = MEM[(const unsigned char *)D.22564];
      D.22566 = (int) D.22565;
      D.22567 = *__s2;
      D.22568 = (int) D.22567;
      __result = D.22566 - D.22568;
      {
        D.22569 = __s2_len != 0;
        D.22570 = __result == 0;
        D.22571 = D.22569 & D.22570;
        if (D.22571 != 0) goto <D.22572>; else goto <D.22573>;
        <D.22572>:
        D.22574 = &MEM[(void *)"4.5" + 1B];
        D.22575 = *D.22574;
        D.22576 = (int) D.22575;
        D.22577 = __s2 + 1;
        D.22578 = *D.22577;
        D.22579 = (int) D.22578;
        __result = D.22576 - D.22579;
        D.22580 = __s2_len > 1;
        D.22570 = __result == 0;
        D.22581 = D.22580 & D.22570;
        if (D.22581 != 0) goto <D.22582>; else goto <D.22583>;
        <D.22582>:
        D.22584 = &MEM[(void *)"4.5" + 2B];
        D.22585 = *D.22584;
        D.22586 = (int) D.22585;
        D.22587 = __s2 + 2;
        D.22588 = *D.22587;
        D.22589 = (int) D.22588;
        __result = D.22586 - D.22589;
        D.22590 = __s2_len > 2;
        D.22570 = __result == 0;
        D.22591 = D.22590 & D.22570;
        if (D.22591 != 0) goto <D.22592>; else goto <D.22593>;
        <D.22592>:
        D.22594 = &MEM[(void *)"4.5" + 3B];
        D.22595 = *D.22594;
        D.22596 = (int) D.22595;
        D.22597 = __s2 + 3;
        D.22598 = *D.22597;
        D.22599 = (int) D.22598;
        __result = D.22596 - D.22599;
        <D.22593>:
        <D.22583>:
        <D.22573>:
      }
      D.20494 = __result;
    }
    iftmp.91 = -D.20494;
    goto <D.22600>;
    <D.22563>:
    D.22552 = &runtime->framework_version;
    iftmp.91 = __builtin_strcmp (D.22552, "4.5");
    <D.22600>:
    D.20495 = iftmp.91;
  }
  if (D.20495 == 0) goto <D.22601>; else goto <D.22602>;
  <D.22601>:
  D.22603 = default_path[0];
  D.22604 = monoeg_g_strdup_printf ("%s/mono/4.5/Facades", D.22603);
  default_path[1] = D.22604;
  <D.22602>:
  <D.22560>:
  D.22542 = corlib;
  return D.22542;
}


load_in_path (const char * basename, const char * * search_path, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  unsigned int i.92;
  unsigned int D.22607;
  const char * * D.22608;
  const char * D.22609;
  int D.22610;
  struct MonoAssembly * D.22613;
  int i;
  char * fullpath;
  struct MonoAssembly * result;

  i = 0;
  goto <D.19620>;
  <D.19619>:
  i.92 = (unsigned int) i;
  D.22607 = i.92 * 4;
  D.22608 = search_path + D.22607;
  D.22609 = *D.22608;
  fullpath = monoeg_g_build_path ("/", D.22609, basename, 0B);
  D.22610 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.22610);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.22611>; else goto <D.22612>;
  <D.22611>:
  D.22613 = result;
  return D.22613;
  <D.22612>:
  i = i + 1;
  <D.19620>:
  i.92 = (unsigned int) i;
  D.22607 = i.92 * 4;
  D.22608 = search_path + D.22607;
  D.22609 = *D.22608;
  if (D.22609 != 0B) goto <D.19619>; else goto <D.19621>;
  <D.19621>:
  D.22613 = 0B;
  return D.22613;
}


mono_assembly_load_full_nosearch (struct MonoAssemblyName * aname, const char * basedir, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.22619;
  struct MonoAssembly * iftmp.93;
  char * * assemblies_path.94;
  int D.20518;
  int iftmp.95;
  int D.20517;
  const char[9] * D.22632;
  unsigned char D.22633;
  int D.22634;
  unsigned char D.22635;
  int D.22636;
  _Bool D.22637;
  _Bool D.22638;
  _Bool D.22639;
  const unsigned char * D.22642;
  unsigned char D.22643;
  int D.22644;
  const unsigned char * D.22645;
  unsigned char D.22646;
  int D.22647;
  _Bool D.22648;
  _Bool D.22649;
  const unsigned char * D.22652;
  unsigned char D.22653;
  int D.22654;
  const unsigned char * D.22655;
  unsigned char D.22656;
  int D.22657;
  _Bool D.22658;
  _Bool D.22659;
  const unsigned char * D.22662;
  unsigned char D.22663;
  int D.22664;
  const unsigned char * D.22665;
  unsigned char D.22666;
  int D.22667;
  const char * D.22669;
  int D.20527;
  int iftmp.96;
  int D.20526;
  const char[13] * D.22674;
  unsigned char D.22675;
  int D.22676;
  unsigned char D.22677;
  int D.22678;
  _Bool D.22679;
  _Bool D.22680;
  _Bool D.22681;
  const unsigned char * D.22684;
  unsigned char D.22685;
  int D.22686;
  const unsigned char * D.22687;
  unsigned char D.22688;
  int D.22689;
  _Bool D.22690;
  _Bool D.22691;
  const unsigned char * D.22694;
  unsigned char D.22695;
  int D.22696;
  const unsigned char * D.22697;
  unsigned char D.22698;
  int D.22699;
  _Bool D.22700;
  _Bool D.22701;
  const unsigned char * D.22704;
  unsigned char D.22705;
  int D.22706;
  const unsigned char * D.22707;
  unsigned char D.22708;
  int D.22709;
  const struct MonoRuntimeInfo * D.22711;
  unsigned int D.22712;
  const char * iftmp.97;
  int D.20536;
  int iftmp.98;
  int D.20535;
  sizetype len.99;
  sizetype D.22725;
  const char[5] * D.22726;
  unsigned char D.22727;
  int D.22728;
  unsigned char D.22729;
  int D.22730;
  _Bool D.22731;
  _Bool D.22732;
  _Bool D.22733;
  const unsigned char * D.22736;
  unsigned char D.22737;
  int D.22738;
  const unsigned char * D.22739;
  unsigned char D.22740;
  int D.22741;
  _Bool D.22742;
  _Bool D.22743;
  const unsigned char * D.22746;
  unsigned char D.22747;
  int D.22748;
  const unsigned char * D.22749;
  unsigned char D.22750;
  int D.22751;
  _Bool D.22752;
  _Bool D.22753;
  const unsigned char * D.22756;
  unsigned char D.22757;
  int D.22758;
  const unsigned char * D.22759;
  unsigned char D.22760;
  int D.22761;
  const char * D.22763;
  int D.20545;
  int iftmp.100;
  int D.20544;
  const char[5] * D.22768;
  unsigned char D.22769;
  int D.22770;
  unsigned char D.22771;
  int D.22772;
  _Bool D.22773;
  _Bool D.22774;
  _Bool D.22775;
  const unsigned char * D.22778;
  unsigned char D.22779;
  int D.22780;
  const unsigned char * D.22781;
  unsigned char D.22782;
  int D.22783;
  _Bool D.22784;
  _Bool D.22785;
  const unsigned char * D.22788;
  unsigned char D.22789;
  int D.22790;
  const unsigned char * D.22791;
  unsigned char D.22792;
  int D.22793;
  _Bool D.22794;
  _Bool D.22795;
  const unsigned char * D.22798;
  unsigned char D.22799;
  int D.22800;
  const unsigned char * D.22801;
  unsigned char D.22802;
  int D.22803;
  unsigned char D.22805;
  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.22615>; else goto <D.22616>;
      <D.22615>:
      aname = mono_assembly_apply_binding (aname, &maped_name_pp);
      <D.22616>:
      result = mono_assembly_loaded_full (aname, refonly);
      if (result != 0B) goto <D.22617>; else goto <D.22618>;
      <D.22617>:
      D.22619 = result;
      return D.22619;
      <D.22618>:
      if (refonly != 0) goto <D.22621>; else goto <D.22622>;
      <D.22621>:
      assemblies_path.94 = assemblies_path;
      iftmp.93 = invoke_assembly_refonly_preload_hook (aname, assemblies_path.94);
      goto <D.22624>;
      <D.22622>:
      assemblies_path.94 = assemblies_path;
      iftmp.93 = invoke_assembly_preload_hook (aname, assemblies_path.94);
      <D.22624>:
      result = iftmp.93;
      if (result != 0B) goto <D.22625>; else goto <D.22626>;
      <D.22625>:
      result->in_gac = 0;
      D.22619 = result;
      return D.22619;
      <D.22626>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = aname->name;
          D.22632 = "mscorlib";
          D.22633 = MEM[(const unsigned char *)D.22632];
          D.22634 = (int) D.22633;
          D.22635 = *__s2;
          D.22636 = (int) D.22635;
          __result = D.22634 - D.22636;
          {
            D.22637 = __s2_len != 0;
            D.22638 = __result == 0;
            D.22639 = D.22637 & D.22638;
            if (D.22639 != 0) goto <D.22640>; else goto <D.22641>;
            <D.22640>:
            D.22642 = &MEM[(void *)"mscorlib" + 1B];
            D.22643 = *D.22642;
            D.22644 = (int) D.22643;
            D.22645 = __s2 + 1;
            D.22646 = *D.22645;
            D.22647 = (int) D.22646;
            __result = D.22644 - D.22647;
            D.22648 = __s2_len > 1;
            D.22638 = __result == 0;
            D.22649 = D.22648 & D.22638;
            if (D.22649 != 0) goto <D.22650>; else goto <D.22651>;
            <D.22650>:
            D.22652 = &MEM[(void *)"mscorlib" + 2B];
            D.22653 = *D.22652;
            D.22654 = (int) D.22653;
            D.22655 = __s2 + 2;
            D.22656 = *D.22655;
            D.22657 = (int) D.22656;
            __result = D.22654 - D.22657;
            D.22658 = __s2_len > 2;
            D.22638 = __result == 0;
            D.22659 = D.22658 & D.22638;
            if (D.22659 != 0) goto <D.22660>; else goto <D.22661>;
            <D.22660>:
            D.22662 = &MEM[(void *)"mscorlib" + 3B];
            D.22663 = *D.22662;
            D.22664 = (int) D.22663;
            D.22665 = __s2 + 3;
            D.22666 = *D.22665;
            D.22667 = (int) D.22666;
            __result = D.22664 - D.22667;
            <D.22661>:
            <D.22651>:
            <D.22641>:
          }
          D.20517 = __result;
        }
        iftmp.95 = -D.20517;
        goto <D.22668>;
        <D.22631>:
        D.22669 = aname->name;
        iftmp.95 = __builtin_strcmp (D.22669, "mscorlib");
        <D.22668>:
        D.20518 = iftmp.95;
      }
      if (D.20518 == 0) goto <D.22627>; else goto <D.22670>;
      <D.22670>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = aname->name;
          D.22674 = "mscorlib.dll";
          D.22675 = MEM[(const unsigned char *)D.22674];
          D.22676 = (int) D.22675;
          D.22677 = *__s2;
          D.22678 = (int) D.22677;
          __result = D.22676 - D.22678;
          {
            D.22679 = __s2_len != 0;
            D.22680 = __result == 0;
            D.22681 = D.22679 & D.22680;
            if (D.22681 != 0) goto <D.22682>; else goto <D.22683>;
            <D.22682>:
            D.22684 = &MEM[(void *)"mscorlib.dll" + 1B];
            D.22685 = *D.22684;
            D.22686 = (int) D.22685;
            D.22687 = __s2 + 1;
            D.22688 = *D.22687;
            D.22689 = (int) D.22688;
            __result = D.22686 - D.22689;
            D.22690 = __s2_len > 1;
            D.22680 = __result == 0;
            D.22691 = D.22690 & D.22680;
            if (D.22691 != 0) goto <D.22692>; else goto <D.22693>;
            <D.22692>:
            D.22694 = &MEM[(void *)"mscorlib.dll" + 2B];
            D.22695 = *D.22694;
            D.22696 = (int) D.22695;
            D.22697 = __s2 + 2;
            D.22698 = *D.22697;
            D.22699 = (int) D.22698;
            __result = D.22696 - D.22699;
            D.22700 = __s2_len > 2;
            D.22680 = __result == 0;
            D.22701 = D.22700 & D.22680;
            if (D.22701 != 0) goto <D.22702>; else goto <D.22703>;
            <D.22702>:
            D.22704 = &MEM[(void *)"mscorlib.dll" + 3B];
            D.22705 = *D.22704;
            D.22706 = (int) D.22705;
            D.22707 = __s2 + 3;
            D.22708 = *D.22707;
            D.22709 = (int) D.22708;
            __result = D.22706 - D.22709;
            <D.22703>:
            <D.22693>:
            <D.22683>:
          }
          D.20526 = __result;
        }
        iftmp.96 = -D.20526;
        goto <D.22710>;
        <D.22673>:
        D.22669 = aname->name;
        iftmp.96 = __builtin_strcmp (D.22669, "mscorlib.dll");
        <D.22710>:
        D.20527 = iftmp.96;
      }
      if (D.20527 == 0) goto <D.22627>; else goto <D.22628>;
      <D.22627>:
      D.22711 = mono_get_runtime_info ();
      D.22619 = mono_assembly_load_corlib (D.22711, status);
      return D.22619;
      <D.22628>:
      D.22669 = aname->name;
      D.22712 = strlen (D.22669);
      len = (int) D.22712;
      ext_index = 0;
      goto <D.20547>;
      <D.20546>:
      if (ext_index == 0) goto <D.22714>; else goto <D.22715>;
      <D.22714>:
      iftmp.97 = ".dll";
      goto <D.22716>;
      <D.22715>:
      iftmp.97 = ".exe";
      <D.22716>:
      ext = iftmp.97;
      if (len > 4) goto <D.22720>; else goto <D.22717>;
      <D.22720>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.22669 = aname->name;
          len.99 = (sizetype) len;
          D.22725 = len.99 + 4294967292;
          __s2 = D.22669 + D.22725;
          D.22726 = ".dll";
          D.22727 = MEM[(const unsigned char *)D.22726];
          D.22728 = (int) D.22727;
          D.22729 = *__s2;
          D.22730 = (int) D.22729;
          __result = D.22728 - D.22730;
          {
            D.22731 = __s2_len != 0;
            D.22732 = __result == 0;
            D.22733 = D.22731 & D.22732;
            if (D.22733 != 0) goto <D.22734>; else goto <D.22735>;
            <D.22734>:
            D.22736 = &MEM[(void *)".dll" + 1B];
            D.22737 = *D.22736;
            D.22738 = (int) D.22737;
            D.22739 = __s2 + 1;
            D.22740 = *D.22739;
            D.22741 = (int) D.22740;
            __result = D.22738 - D.22741;
            D.22742 = __s2_len > 1;
            D.22732 = __result == 0;
            D.22743 = D.22742 & D.22732;
            if (D.22743 != 0) goto <D.22744>; else goto <D.22745>;
            <D.22744>:
            D.22746 = &MEM[(void *)".dll" + 2B];
            D.22747 = *D.22746;
            D.22748 = (int) D.22747;
            D.22749 = __s2 + 2;
            D.22750 = *D.22749;
            D.22751 = (int) D.22750;
            __result = D.22748 - D.22751;
            D.22752 = __s2_len > 2;
            D.22732 = __result == 0;
            D.22753 = D.22752 & D.22732;
            if (D.22753 != 0) goto <D.22754>; else goto <D.22755>;
            <D.22754>:
            D.22756 = &MEM[(void *)".dll" + 3B];
            D.22757 = *D.22756;
            D.22758 = (int) D.22757;
            D.22759 = __s2 + 3;
            D.22760 = *D.22759;
            D.22761 = (int) D.22760;
            __result = D.22758 - D.22761;
            <D.22755>:
            <D.22745>:
            <D.22735>:
          }
          D.20535 = __result;
        }
        iftmp.98 = -D.20535;
        goto <D.22762>;
        <D.22723>:
        D.22669 = aname->name;
        len.99 = (sizetype) len;
        D.22725 = len.99 + 4294967292;
        D.22763 = D.22669 + D.22725;
        iftmp.98 = __builtin_strcmp (D.22763, ".dll");
        <D.22762>:
        D.20536 = iftmp.98;
      }
      if (D.20536 == 0) goto <D.22718>; else goto <D.22764>;
      <D.22764>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.22669 = aname->name;
          len.99 = (sizetype) len;
          D.22725 = len.99 + 4294967292;
          __s2 = D.22669 + D.22725;
          D.22768 = ".exe";
          D.22769 = MEM[(const unsigned char *)D.22768];
          D.22770 = (int) D.22769;
          D.22771 = *__s2;
          D.22772 = (int) D.22771;
          __result = D.22770 - D.22772;
          {
            D.22773 = __s2_len != 0;
            D.22774 = __result == 0;
            D.22775 = D.22773 & D.22774;
            if (D.22775 != 0) goto <D.22776>; else goto <D.22777>;
            <D.22776>:
            D.22778 = &MEM[(void *)".exe" + 1B];
            D.22779 = *D.22778;
            D.22780 = (int) D.22779;
            D.22781 = __s2 + 1;
            D.22782 = *D.22781;
            D.22783 = (int) D.22782;
            __result = D.22780 - D.22783;
            D.22784 = __s2_len > 1;
            D.22774 = __result == 0;
            D.22785 = D.22784 & D.22774;
            if (D.22785 != 0) goto <D.22786>; else goto <D.22787>;
            <D.22786>:
            D.22788 = &MEM[(void *)".exe" + 2B];
            D.22789 = *D.22788;
            D.22790 = (int) D.22789;
            D.22791 = __s2 + 2;
            D.22792 = *D.22791;
            D.22793 = (int) D.22792;
            __result = D.22790 - D.22793;
            D.22794 = __s2_len > 2;
            D.22774 = __result == 0;
            D.22795 = D.22794 & D.22774;
            if (D.22795 != 0) goto <D.22796>; else goto <D.22797>;
            <D.22796>:
            D.22798 = &MEM[(void *)".exe" + 3B];
            D.22799 = *D.22798;
            D.22800 = (int) D.22799;
            D.22801 = __s2 + 3;
            D.22802 = *D.22801;
            D.22803 = (int) D.22802;
            __result = D.22800 - D.22803;
            <D.22797>:
            <D.22787>:
            <D.22777>:
          }
          D.20544 = __result;
        }
        iftmp.100 = -D.20544;
        goto <D.22804>;
        <D.22767>:
        D.22669 = aname->name;
        len.99 = (sizetype) len;
        D.22725 = len.99 + 4294967292;
        D.22763 = D.22669 + D.22725;
        iftmp.100 = __builtin_strcmp (D.22763, ".exe");
        <D.22804>:
        D.20545 = iftmp.100;
      }
      if (D.20545 == 0) goto <D.22718>; else goto <D.22717>;
      <D.22718>:
      D.22669 = aname->name;
      filename = monoeg_strdup (D.22669);
      ext_index = ext_index + 1;
      goto <D.22719>;
      <D.22717>:
      D.22669 = aname->name;
      filename = monoeg_g_strconcat (D.22669, ext, 0B);
      <D.22719>:
      D.22805 = (unsigned char) refonly;
      result = mono_assembly_load_from_gac (aname, filename, status, D.22805);
      if (result != 0B) goto <D.22806>; else goto <D.22807>;
      <D.22806>:
      monoeg_g_free (filename);
      D.22619 = result;
      return D.22619;
      <D.22807>:
      if (basedir != 0B) goto <D.22808>; else goto <D.22809>;
      <D.22808>:
      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.22810>; else goto <D.22811>;
      <D.22810>:
      result->in_gac = 0;
      monoeg_g_free (filename);
      D.22619 = result;
      return D.22619;
      <D.22811>:
      <D.22809>:
      D.22805 = (unsigned char) refonly;
      result = load_in_path (filename, &default_path, status, D.22805);
      if (result != 0B) goto <D.22812>; else goto <D.22813>;
      <D.22812>:
      result->in_gac = 0;
      <D.22813>:
      monoeg_g_free (filename);
      if (result != 0B) goto <D.22814>; else goto <D.22815>;
      <D.22814>:
      D.22619 = result;
      return D.22619;
      <D.22815>:
      ext_index = ext_index + 1;
      <D.20547>:
      if (ext_index <= 1) goto <D.20546>; else goto <D.20548>;
      <D.20548>:
      D.22619 = result;
      return D.22619;
    }
  finally
    {
      maped_aname = {CLOBBER};
      maped_name_pp = {CLOBBER};
    }
}


mono_assembly_apply_binding (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  unsigned char D.22818;
  struct MonoAssemblyName * D.22821;
  union mono_mutex_t * D.22824;
  _Bool D.22827;
  long int D.22828;
  long int D.22829;
  _Bool D.22834;
  long int D.22835;
  long int D.22836;
  int D.22841;
  struct MonoAppDomainSetup * D.22846;
  struct MonoString * D.22849;
  _Bool D.22854;
  long int D.22855;
  long int D.22856;
  int D.22859;
  short unsigned int D.22864;
  int D.22865;
  short unsigned int D.22866;
  int D.22867;
  char * D.22872;
  gchar * D.22873;
  char * D.22874;
  gchar * D.22875;
  int D.22876;
  _Bool D.22879;
  long int D.22880;
  long int D.22881;
  unsigned char D.22886;
  unsigned char D.22887;
  const char * D.22894;
  gchar * D.22895;
  const char * D.22896;
  gchar * D.22897;
  guchar[17] * D.22898;
  mono_byte[17] * D.22899;
  struct GSList * loaded_assembly_bindings.101;
  struct GSList * loaded_assembly_bindings.102;
  int D.22908;
  struct MonoAssemblyBindingInfo * info;
  struct MonoAssemblyBindingInfo * info2;
  struct MonoImage * ppimage;
  struct MonoDomain * domain;

  D.22818 = aname->public_key_token[0];
  if (D.22818 == 0) goto <D.22819>; else goto <D.22820>;
  <D.22819>:
  D.22821 = aname;
  return D.22821;
  <D.22820>:
  domain = mono_domain_get ();
  mono_assembly_binding_lock ();
  info = search_binding_loaded (aname);
  mono_assembly_binding_unlock ();
  if (info == 0B) goto <D.22822>; else goto <D.22823>;
  <D.22822>:
  {
    int ret;

    D.22824 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22824);
    if (ret != 0) goto <D.22825>; else goto <D.22826>;
    <D.22825>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22826>:
    D.22827 = ret != 0;
    D.22828 = (long int) D.22827;
    D.22829 = __builtin_expect (D.22828, 0);
    if (D.22829 != 0) goto <D.22830>; else goto <D.22831>;
    <D.22830>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2644, "ret == 0");
    <D.22831>:
  }
  info = get_per_domain_assembly_binding_info (domain, aname);
  {
    int ret;

    D.22824 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22824);
    if (ret != 0) goto <D.22832>; else goto <D.22833>;
    <D.22832>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22833>:
    D.22834 = ret != 0;
    D.22835 = (long int) D.22834;
    D.22836 = __builtin_expect (D.22835, 0);
    if (D.22836 != 0) goto <D.22837>; else goto <D.22838>;
    <D.22837>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2646, "ret == 0");
    <D.22838>:
  }
  <D.22823>:
  if (info != 0B) goto <D.22839>; else goto <D.22840>;
  <D.22839>:
  D.22841 = check_policy_versions (info, aname);
  if (D.22841 == 0) goto <D.22842>; else goto <D.22843>;
  <D.22842>:
  D.22821 = aname;
  return D.22821;
  <D.22843>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.22821 = dest_name;
  return D.22821;
  <D.22840>:
  if (domain != 0B) goto <D.22844>; else goto <D.22845>;
  <D.22844>:
  D.22846 = domain->setup;
  if (D.22846 != 0B) goto <D.22847>; else goto <D.22848>;
  <D.22847>:
  D.22846 = domain->setup;
  D.22849 = D.22846->configuration_file;
  if (D.22849 != 0B) goto <D.22850>; else goto <D.22851>;
  <D.22850>:
  {
    int ret;

    D.22824 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22824);
    if (ret != 0) goto <D.22852>; else goto <D.22853>;
    <D.22852>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22853>:
    D.22854 = ret != 0;
    D.22855 = (long int) D.22854;
    D.22856 = __builtin_expect (D.22855, 0);
    if (D.22856 != 0) goto <D.22857>; else goto <D.22858>;
    <D.22857>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2658, "ret == 0");
    <D.22858>:
  }
  D.22859 = domain->assembly_bindings_parsed;
  if (D.22859 == 0) goto <D.22860>; else goto <D.22861>;
  <D.22860>:
  {
    gchar * domain_config_file_name;
    gchar * domain_config_file_path;

    D.22846 = domain->setup;
    D.22849 = D.22846->configuration_file;
    domain_config_file_name = mono_string_to_utf8 (D.22849);
    domain_config_file_path = mono_portability_find_file (domain_config_file_name, 1);
    if (domain_config_file_path == 0B) goto <D.22862>; else goto <D.22863>;
    <D.22862>:
    domain_config_file_path = domain_config_file_name;
    <D.22863>:
    D.22864 = aname->major;
    D.22865 = (int) D.22864;
    D.22866 = aname->minor;
    D.22867 = (int) D.22866;
    mono_config_parse_assembly_bindings (domain_config_file_path, D.22865, D.22867, domain, assembly_binding_info_parsed);
    domain->assembly_bindings_parsed = 1;
    if (domain_config_file_name != domain_config_file_path) goto <D.22868>; else goto <D.22869>;
    <D.22868>:
    monoeg_g_free (domain_config_file_name);
    <D.22869>:
    monoeg_g_free (domain_config_file_path);
  }
  <D.22861>:
  info2 = get_per_domain_assembly_binding_info (domain, aname);
  if (info2 != 0B) goto <D.22870>; else goto <D.22871>;
  <D.22870>:
  info = monoeg_g_memdup (info2, 68);
  D.22872 = info2->name;
  D.22873 = monoeg_strdup (D.22872);
  info->name = D.22873;
  D.22874 = info2->culture;
  D.22875 = monoeg_strdup (D.22874);
  info->culture = D.22875;
  D.22876 = domain->domain_id;
  info->domain_id = D.22876;
  <D.22871>:
  {
    int ret;

    D.22824 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22824);
    if (ret != 0) goto <D.22877>; else goto <D.22878>;
    <D.22877>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22878>:
    D.22879 = ret != 0;
    D.22880 = (long int) D.22879;
    D.22881 = __builtin_expect (D.22880, 0);
    if (D.22881 != 0) goto <D.22882>; else goto <D.22883>;
    <D.22882>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2682, "ret == 0");
    <D.22883>:
  }
  <D.22851>:
  <D.22848>:
  <D.22845>:
  if (info == 0B) goto <D.22884>; else goto <D.22885>;
  <D.22884>:
  info = monoeg_malloc0 (68);
  D.22864 = aname->major;
  D.22865 = (int) D.22864;
  info->major = D.22865;
  D.22866 = aname->minor;
  D.22867 = (int) D.22866;
  info->minor = D.22867;
  <D.22885>:
  D.22886 = BIT_FIELD_REF <*info, 8, 480>;
  D.22887 = D.22886 & 8;
  if (D.22887 == 0) goto <D.22888>; else goto <D.22889>;
  <D.22888>:
  ppimage = mono_assembly_load_publisher_policy (aname);
  if (ppimage != 0B) goto <D.22890>; else goto <D.22891>;
  <D.22890>:
  get_publisher_policy_info (ppimage, aname, info);
  mono_image_close (ppimage);
  <D.22891>:
  <D.22889>:
  D.22886 = BIT_FIELD_REF <*info, 8, 480>;
  D.22887 = D.22886 & 8;
  if (D.22887 == 0) goto <D.22892>; else goto <D.22893>;
  <D.22892>:
  D.22894 = aname->name;
  D.22895 = monoeg_strdup (D.22894);
  info->name = D.22895;
  D.22896 = aname->culture;
  D.22897 = monoeg_strdup (D.22896);
  info->culture = D.22897;
  D.22898 = &info->public_key_token;
  D.22899 = &aname->public_key_token;
  monoeg_g_strlcpy (D.22898, D.22899, 17);
  <D.22893>:
  mono_assembly_binding_lock ();
  info2 = search_binding_loaded (aname);
  if (info2 != 0B) goto <D.22900>; else goto <D.22901>;
  <D.22900>:
  mono_assembly_binding_info_free (info);
  monoeg_g_free (info);
  info = info2;
  goto <D.22902>;
  <D.22901>:
  loaded_assembly_bindings.101 = loaded_assembly_bindings;
  loaded_assembly_bindings.102 = monoeg_g_slist_prepend (loaded_assembly_bindings.101, info);
  loaded_assembly_bindings = loaded_assembly_bindings.102;
  <D.22902>:
  mono_assembly_binding_unlock ();
  D.22886 = BIT_FIELD_REF <*info, 8, 480>;
  D.22887 = D.22886 & 8;
  if (D.22887 == 0) goto <D.22905>; else goto <D.22907>;
  <D.22907>:
  D.22908 = check_policy_versions (info, aname);
  if (D.22908 == 0) goto <D.22905>; else goto <D.22906>;
  <D.22905>:
  D.22821 = aname;
  return D.22821;
  <D.22906>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.22821 = dest_name;
  return D.22821;
}


assembly_binding_info_parsed (struct MonoAssemblyBindingInfo * info, void * user_data)
{
  int D.20418;
  char * D.22912;
  char * D.22913;
  int D.22916;
  struct MonoMemPool * D.22919;
  char * D.22922;
  char * D.22923;
  char * D.22926;
  struct GSList * D.22927;
  struct GSList * D.22928;
  struct MonoAssemblyBindingInfo * info_copy;
  struct GSList * tmp;
  struct MonoAssemblyBindingInfo * info_tmp;
  struct MonoDomain * domain;

  domain = user_data;
  if (domain == 0B) goto <D.22910>; else goto <D.22911>;
  <D.22910>:
  return;
  <D.22911>:
  tmp = domain->assembly_bindings;
  goto <D.20420>;
  <D.20419>:
  info_tmp = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.22912 = info->name;
    D.22913 = info_tmp->name;
    D.20418 = __builtin_strcmp (D.22912, D.22913);
  }
  if (D.20418 == 0) goto <D.22914>; else goto <D.22915>;
  <D.22914>:
  D.22916 = info_versions_equal (info, info_tmp);
  if (D.22916 != 0) goto <D.22917>; else goto <D.22918>;
  <D.22917>:
  return;
  <D.22918>:
  <D.22915>:
  tmp = tmp->next;
  <D.20420>:
  if (tmp != 0B) goto <D.20419>; else goto <D.20421>;
  <D.20421>:
  D.22919 = domain->mp;
  info_copy = mono_mempool_alloc0 (D.22919, 68);
  memcpy (info_copy, info, 68);
  D.22912 = info->name;
  if (D.22912 != 0B) goto <D.22920>; else goto <D.22921>;
  <D.22920>:
  D.22919 = domain->mp;
  D.22912 = info->name;
  D.22922 = mono_mempool_strdup (D.22919, D.22912);
  info_copy->name = D.22922;
  <D.22921>:
  D.22923 = info->culture;
  if (D.22923 != 0B) goto <D.22924>; else goto <D.22925>;
  <D.22924>:
  D.22919 = domain->mp;
  D.22923 = info->culture;
  D.22926 = mono_mempool_strdup (D.22919, D.22923);
  info_copy->culture = D.22926;
  <D.22925>:
  D.22919 = domain->mp;
  D.22927 = domain->assembly_bindings;
  D.22928 = g_slist_append_mempool (D.22919, D.22927, info_copy);
  domain->assembly_bindings = D.22928;
}


info_versions_equal (struct MonoAssemblyBindingInfo * left, struct MonoAssemblyBindingInfo * right)
{
  unsigned char D.22930;
  unsigned char D.22931;
  unsigned char D.22932;
  unsigned char D.22933;
  gboolean D.22936;
  unsigned char D.22937;
  unsigned char D.22940;
  unsigned char D.22943;
  struct AssemblyVersionSet * D.22946;
  struct AssemblyVersionSet * D.22947;
  int D.22948;
  unsigned char D.22951;
  struct AssemblyVersionSet * D.22954;
  struct AssemblyVersionSet * D.22955;
  int D.22956;
  unsigned char D.22959;
  struct AssemblyVersionSet * D.22962;
  struct AssemblyVersionSet * D.22963;
  int D.22964;

  D.22930 = BIT_FIELD_REF <*left, 8, 480>;
  D.22931 = BIT_FIELD_REF <*right, 8, 480>;
  D.22932 = D.22930 ^ D.22931;
  D.22933 = D.22932 & 1;
  if (D.22933 != 0) goto <D.22934>; else goto <D.22935>;
  <D.22934>:
  D.22936 = 0;
  return D.22936;
  <D.22935>:
  D.22930 = BIT_FIELD_REF <*left, 8, 480>;
  D.22931 = BIT_FIELD_REF <*right, 8, 480>;
  D.22932 = D.22930 ^ D.22931;
  D.22937 = D.22932 & 2;
  if (D.22937 != 0) goto <D.22938>; else goto <D.22939>;
  <D.22938>:
  D.22936 = 0;
  return D.22936;
  <D.22939>:
  D.22930 = BIT_FIELD_REF <*left, 8, 480>;
  D.22931 = BIT_FIELD_REF <*right, 8, 480>;
  D.22932 = D.22930 ^ D.22931;
  D.22940 = D.22932 & 4;
  if (D.22940 != 0) goto <D.22941>; else goto <D.22942>;
  <D.22941>:
  D.22936 = 0;
  return D.22936;
  <D.22942>:
  D.22930 = BIT_FIELD_REF <*left, 8, 480>;
  D.22943 = D.22930 & 1;
  if (D.22943 != 0) goto <D.22944>; else goto <D.22945>;
  <D.22944>:
  D.22946 = &left->old_version_bottom;
  D.22947 = &right->old_version_bottom;
  D.22948 = info_compare_versions (D.22946, D.22947);
  if (D.22948 == 0) goto <D.22949>; else goto <D.22950>;
  <D.22949>:
  D.22936 = 0;
  return D.22936;
  <D.22950>:
  <D.22945>:
  D.22930 = BIT_FIELD_REF <*left, 8, 480>;
  D.22951 = D.22930 & 2;
  if (D.22951 != 0) goto <D.22952>; else goto <D.22953>;
  <D.22952>:
  D.22954 = &left->old_version_top;
  D.22955 = &right->old_version_top;
  D.22956 = info_compare_versions (D.22954, D.22955);
  if (D.22956 == 0) goto <D.22957>; else goto <D.22958>;
  <D.22957>:
  D.22936 = 0;
  return D.22936;
  <D.22958>:
  <D.22953>:
  D.22930 = BIT_FIELD_REF <*left, 8, 480>;
  D.22959 = D.22930 & 4;
  if (D.22959 != 0) goto <D.22960>; else goto <D.22961>;
  <D.22960>:
  D.22962 = &left->new_version;
  D.22963 = &right->new_version;
  D.22964 = info_compare_versions (D.22962, D.22963);
  if (D.22964 == 0) goto <D.22965>; else goto <D.22966>;
  <D.22965>:
  D.22936 = 0;
  return D.22936;
  <D.22966>:
  <D.22961>:
  D.22936 = 1;
  return D.22936;
}


info_compare_versions (struct AssemblyVersionSet * left, struct AssemblyVersionSet * right)
{
  short unsigned int D.22970;
  short unsigned int D.22971;
  short unsigned int D.22973;
  short unsigned int D.22974;
  short unsigned int D.22976;
  short unsigned int D.22977;
  short unsigned int D.22979;
  short unsigned int D.22980;
  gboolean D.22981;

  D.22970 = left->major;
  D.22971 = right->major;
  if (D.22970 != D.22971) goto <D.22968>; else goto <D.22972>;
  <D.22972>:
  D.22973 = left->minor;
  D.22974 = right->minor;
  if (D.22973 != D.22974) goto <D.22968>; else goto <D.22975>;
  <D.22975>:
  D.22976 = left->build;
  D.22977 = right->build;
  if (D.22976 != D.22977) goto <D.22968>; else goto <D.22978>;
  <D.22978>:
  D.22979 = left->revision;
  D.22980 = right->revision;
  if (D.22979 != D.22980) goto <D.22968>; else goto <D.22969>;
  <D.22968>:
  D.22981 = 0;
  return D.22981;
  <D.22969>:
  D.22981 = 1;
  return D.22981;
}


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

  new_list = mono_mempool_alloc (mp, 8);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.22983>; else goto <D.22984>;
  <D.22983>:
  last = list;
  goto <D.13076>;
  <D.13075>:
  last = last->next;
  <D.13076>:
  D.22985 = last->next;
  if (D.22985 != 0B) goto <D.13075>; else goto <D.13077>;
  <D.13077>:
  last->next = new_list;
  D.22986 = list;
  return D.22986;
  <D.22984>:
  D.22986 = new_list;
  return D.22986;
}


get_per_domain_assembly_binding_info (struct MonoDomain * domain, struct MonoAssemblyName * aname)
{
  struct GSList * D.22988;
  struct MonoAssemblyBindingInfo * D.22991;
  int D.20445;
  const char * D.22994;
  char * D.22995;
  int D.22998;
  unsigned char D.23005;
  unsigned char D.23007;
  unsigned char D.23008;
  int D.23010;
  struct MonoAssemblyBindingInfo * info;
  struct GSList * list;

  D.22988 = domain->assembly_bindings;
  if (D.22988 == 0B) goto <D.22989>; else goto <D.22990>;
  <D.22989>:
  D.22991 = 0B;
  return D.22991;
  <D.22990>:
  info = 0B;
  list = domain->assembly_bindings;
  goto <D.20448>;
  <D.20447>:
  info = list->data;
  if (info != 0B) goto <D.22992>; else goto <D.22993>;
  <D.22992>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.22994 = aname->name;
    D.22995 = info->name;
    D.20445 = __builtin_strcmp (D.22994, D.22995);
  }
  if (D.20445 == 0) goto <D.22996>; else goto <D.22997>;
  <D.22996>:
  D.22998 = info_major_minor_in_range (info, aname);
  if (D.22998 != 0) goto <D.20446>; else goto <D.22999>;
  <D.22999>:
  <D.22997>:
  <D.22993>:
  info = 0B;
  list = list->next;
  <D.20448>:
  if (list != 0B) goto <D.20447>; else goto <D.20446>;
  <D.20446>:
  if (info != 0B) goto <D.23000>; else goto <D.23001>;
  <D.23000>:
  D.22995 = info->name;
  if (D.22995 != 0B) goto <D.23004>; else goto <D.23002>;
  <D.23004>:
  D.23005 = info->public_key_token[0];
  if (D.23005 != 0) goto <D.23006>; else goto <D.23002>;
  <D.23006>:
  D.23007 = BIT_FIELD_REF <*info, 8, 480>;
  D.23008 = D.23007 & 5;
  if (D.23008 == 5) goto <D.23009>; else goto <D.23002>;
  <D.23009>:
  D.23010 = assembly_binding_maps_name (info, aname);
  if (D.23010 != 0) goto <D.23011>; else goto <D.23002>;
  <D.23011>:
  info->is_valid = 1;
  goto <D.23003>;
  <D.23002>:
  info->is_valid = 0;
  <D.23003>:
  <D.23001>:
  D.22991 = info;
  return D.22991;
}


info_major_minor_in_range (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  short unsigned int D.23013;
  int D.23014;
  short unsigned int D.23015;
  int D.23016;
  unsigned char D.23017;
  unsigned char D.23018;
  gboolean D.23021;
  short unsigned int D.23022;
  int D.23023;
  short unsigned int D.23024;
  int D.23025;
  int D.23026;
  unsigned char D.23029;
  short unsigned int D.23032;
  int D.23033;
  short unsigned int D.23034;
  int D.23035;
  int D.23036;
  int aname_version_number;

  D.23013 = aname->major;
  D.23014 = (int) D.23013;
  D.23015 = aname->minor;
  D.23016 = (int) D.23015;
  aname_version_number = get_version_number (D.23014, D.23016);
  D.23017 = BIT_FIELD_REF <*info, 8, 480>;
  D.23018 = D.23017 & 1;
  if (D.23018 == 0) goto <D.23019>; else goto <D.23020>;
  <D.23019>:
  D.23021 = 0;
  return D.23021;
  <D.23020>:
  D.23022 = info->old_version_bottom.major;
  D.23023 = (int) D.23022;
  D.23024 = info->old_version_bottom.minor;
  D.23025 = (int) D.23024;
  D.23026 = get_version_number (D.23023, D.23025);
  if (D.23026 > aname_version_number) goto <D.23027>; else goto <D.23028>;
  <D.23027>:
  D.23021 = 0;
  return D.23021;
  <D.23028>:
  D.23017 = BIT_FIELD_REF <*info, 8, 480>;
  D.23029 = D.23017 & 2;
  if (D.23029 != 0) goto <D.23030>; else goto <D.23031>;
  <D.23030>:
  D.23032 = info->old_version_top.major;
  D.23033 = (int) D.23032;
  D.23034 = info->old_version_top.minor;
  D.23035 = (int) D.23034;
  D.23036 = get_version_number (D.23033, D.23035);
  if (D.23036 < aname_version_number) goto <D.23037>; else goto <D.23038>;
  <D.23037>:
  D.23021 = 0;
  return D.23021;
  <D.23038>:
  <D.23031>:
  D.23013 = aname->major;
  D.23014 = (int) D.23013;
  info->major = D.23014;
  D.23015 = aname->minor;
  D.23016 = (int) D.23015;
  info->minor = D.23016;
  D.23021 = 1;
  return D.23021;
}


get_version_number (int major, int minor)
{
  int D.23040;
  int D.23041;

  D.23041 = major * 256;
  D.23040 = D.23041 + minor;
  return D.23040;
}


assembly_binding_maps_name (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  char * D.23046;
  gboolean D.23047;
  int D.19557;
  const char * D.23048;
  int D.23053;
  short unsigned int D.23054;
  int D.23055;
  int D.23057;
  short unsigned int D.23058;
  int D.23059;
  int iftmp.103;
  char * D.23063;
  char D.23065;
  _Bool D.23067;
  int iftmp.104;
  const char * D.23071;
  char D.23073;
  _Bool D.23075;
  _Bool D.23076;
  int D.19566;
  guchar[17] * D.23085;
  mono_byte[17] * D.23086;
  int D.23087;

  if (info == 0B) goto <D.23043>; else goto <D.23045>;
  <D.23045>:
  D.23046 = info->name;
  if (D.23046 == 0B) goto <D.23043>; else goto <D.23044>;
  <D.23043>:
  D.23047 = 0;
  return D.23047;
  <D.23044>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23046 = info->name;
    D.23048 = aname->name;
    D.19557 = __builtin_strcmp (D.23046, D.23048);
  }
  if (D.19557 != 0) goto <D.23049>; else goto <D.23050>;
  <D.23049>:
  D.23047 = 0;
  return D.23047;
  <D.23050>:
  D.23053 = info->major;
  D.23054 = aname->major;
  D.23055 = (int) D.23054;
  if (D.23053 != D.23055) goto <D.23051>; else goto <D.23056>;
  <D.23056>:
  D.23057 = info->minor;
  D.23058 = aname->minor;
  D.23059 = (int) D.23058;
  if (D.23057 != D.23059) goto <D.23051>; else goto <D.23052>;
  <D.23051>:
  D.23047 = 0;
  return D.23047;
  <D.23052>:
  D.23063 = info->culture;
  if (D.23063 != 0B) goto <D.23064>; else goto <D.23061>;
  <D.23064>:
  D.23063 = info->culture;
  D.23065 = *D.23063;
  if (D.23065 != 0) goto <D.23066>; else goto <D.23061>;
  <D.23066>:
  iftmp.103 = 1;
  goto <D.23062>;
  <D.23061>:
  iftmp.103 = 0;
  <D.23062>:
  D.23067 = (_Bool) iftmp.103;
  D.23071 = aname->culture;
  if (D.23071 != 0B) goto <D.23072>; else goto <D.23069>;
  <D.23072>:
  D.23071 = aname->culture;
  D.23073 = *D.23071;
  if (D.23073 != 0) goto <D.23074>; else goto <D.23069>;
  <D.23074>:
  iftmp.104 = 1;
  goto <D.23070>;
  <D.23069>:
  iftmp.104 = 0;
  <D.23070>:
  D.23075 = (_Bool) iftmp.104;
  D.23076 = D.23067 ^ D.23075;
  if (D.23076 != 0) goto <D.23077>; else goto <D.23078>;
  <D.23077>:
  D.23047 = 0;
  return D.23047;
  <D.23078>:
  D.23063 = info->culture;
  if (D.23063 != 0B) goto <D.23079>; else goto <D.23080>;
  <D.23079>:
  D.23071 = aname->culture;
  if (D.23071 != 0B) goto <D.23081>; else goto <D.23082>;
  <D.23081>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23063 = info->culture;
    D.23071 = aname->culture;
    D.19566 = __builtin_strcmp (D.23063, D.23071);
  }
  if (D.19566 != 0) goto <D.23083>; else goto <D.23084>;
  <D.23083>:
  D.23047 = 0;
  return D.23047;
  <D.23084>:
  <D.23082>:
  <D.23080>:
  D.23085 = &info->public_key_token;
  D.23086 = &aname->public_key_token;
  D.23087 = mono_public_tokens_are_equal (D.23085, D.23086);
  if (D.23087 == 0) goto <D.23088>; else goto <D.23089>;
  <D.23088>:
  D.23047 = 0;
  return D.23047;
  <D.23089>:
  D.23047 = 1;
  return D.23047;
}


mono_assembly_load_publisher_policy (struct MonoAssemblyName * aname)
{
  const char * D.23091;
  char * D.23092;
  unsigned int D.23095;
  unsigned int D.23096;
  unsigned int len.105;
  unsigned int len.106;
  const char * D.23100;
  short unsigned int D.23104;
  int D.23105;
  short unsigned int D.23106;
  int D.23107;
  mono_byte[17] * D.23108;
  char * * extra_gac_paths.107;
  gchar * D.23112;
  struct MonoImage * D.23116;
  const char * D.23117;
  struct MonoImage * image;
  gchar * filename;
  gchar * pname;
  gchar * name;
  gchar * culture;
  gchar * version;
  gchar * fullpath;
  gchar * subpath;
  gchar * * paths;
  gint32 len;

  D.23091 = aname->name;
  D.23092 = strstr (D.23091, ".dll");
  if (D.23092 != 0B) goto <D.23093>; else goto <D.23094>;
  <D.23093>:
  D.23091 = aname->name;
  D.23095 = strlen (D.23091);
  D.23096 = D.23095 + 4294967292;
  len = (gint32) D.23096;
  len.105 = (unsigned int) len;
  name = monoeg_malloc (len.105);
  D.23091 = aname->name;
  len.106 = (unsigned int) len;
  strncpy (name, D.23091, len.106);
  goto <D.23099>;
  <D.23094>:
  D.23091 = aname->name;
  name = monoeg_strdup (D.23091);
  <D.23099>:
  D.23100 = aname->culture;
  if (D.23100 != 0B) goto <D.23101>; else goto <D.23102>;
  <D.23101>:
  D.23100 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.23100, -1);
  goto <D.23103>;
  <D.23102>:
  culture = monoeg_strdup ("");
  <D.23103>:
  D.23104 = aname->major;
  D.23105 = (int) D.23104;
  D.23106 = aname->minor;
  D.23107 = (int) D.23106;
  pname = monoeg_g_strdup_printf ("policy.%d.%d.%s", D.23105, D.23107, name);
  D.23108 = &aname->public_key_token;
  version = monoeg_g_strdup_printf ("0.0.0.0_%s_%s", culture, D.23108);
  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.107 = extra_gac_paths;
  if (extra_gac_paths.107 != 0B) goto <D.23110>; else goto <D.23111>;
  <D.23110>:
  paths = extra_gac_paths;
  goto <D.20379>;
  <D.20378>:
  D.23112 = *paths;
  fullpath = monoeg_g_build_path ("/", D.23112, "lib", "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (fullpath);
  paths = paths + 4;
  <D.20379>:
  if (image == 0B) goto <D.23113>; else goto <D.20380>;
  <D.23113>:
  D.23112 = *paths;
  if (D.23112 != 0B) goto <D.20378>; else goto <D.20380>;
  <D.20380>:
  <D.23111>:
  if (image != 0B) goto <D.23114>; else goto <D.23115>;
  <D.23114>:
  monoeg_g_free (subpath);
  D.23116 = image;
  return D.23116;
  <D.23115>:
  D.23117 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.23117, "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (subpath);
  monoeg_g_free (fullpath);
  D.23116 = image;
  return D.23116;
}


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

  D.23120 = __builtin_object_size (__dest, 1);
  D.23119 = __builtin___strncpy_chk (__dest, __src, __len, D.23120);
  return D.23119;
}


get_publisher_policy_info (struct MonoImage * image, struct MonoAssemblyName * aname, struct MonoAssemblyBindingInfo * binding_info)
{
  <unnamed-unsigned:24> D.23122;
  int D.23123;
  unsigned int D.23126;
  unsigned int D.23127;
  unsigned int D.23130;
  _Bool D.23131;
  long int D.23132;
  long int D.23133;
  char * D.23136;
  char * D.23137;
  gchar * D.23140;
  char * D.23143;
  unsigned char D.23145;
  unsigned char D.23147;
  unsigned char D.23148;
  int D.23150;
  struct MonoTableInfo * t;
  guint32 cols[4];
  const gchar * filename;
  gchar * subpath;
  gchar * fullpath;

  try
    {
      t = &image->tables[40];
      D.23122 = t->rows;
      D.23123 = (int) D.23122;
      if (D.23123 <= 0) goto <D.23124>; else goto <D.23125>;
      <D.23124>:
      binding_info->is_valid = 0;
      return;
      <D.23125>:
      mono_metadata_decode_row (t, 0, &cols, 4);
      D.23126 = cols[3];
      D.23127 = D.23126 & 3;
      if (D.23127 != 0) goto <D.23128>; else goto <D.23129>;
      <D.23128>:
      binding_info->is_valid = 0;
      return;
      <D.23129>:
      D.23130 = cols[2];
      filename = mono_metadata_string_heap (image, D.23130);
      D.23131 = filename == 0B;
      D.23132 = (long int) D.23131;
      D.23133 = __builtin_expect (D.23132, 0);
      if (D.23133 != 0) goto <D.23134>; else goto <D.23135>;
      <D.23134>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 370, "filename != NULL");
      <D.23135>:
      D.23136 = image->name;
      subpath = monoeg_g_path_get_dirname (D.23136);
      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.23137 = binding_info->culture;
      if (D.23137 == 0B) goto <D.23138>; else goto <D.23139>;
      <D.23138>:
      D.23140 = monoeg_strdup ("");
      binding_info->culture = D.23140;
      <D.23139>:
      D.23143 = binding_info->name;
      if (D.23143 == 0B) goto <D.23141>; else goto <D.23144>;
      <D.23144>:
      D.23145 = binding_info->public_key_token[0];
      if (D.23145 == 0) goto <D.23141>; else goto <D.23146>;
      <D.23146>:
      D.23147 = BIT_FIELD_REF <*binding_info, 8, 480>;
      D.23148 = D.23147 & 5;
      if (D.23148 != 5) goto <D.23141>; else goto <D.23149>;
      <D.23149>:
      D.23150 = assembly_binding_maps_name (binding_info, aname);
      if (D.23150 == 0) goto <D.23141>; else goto <D.23142>;
      <D.23141>:
      mono_assembly_binding_info_free (binding_info);
      binding_info->is_valid = 0;
      return;
      <D.23142>:
      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.23154;
  struct MonoAssemblyBindingInfo * D.23157;
  struct GSList * tmp;

  tmp = loaded_assembly_bindings;
  goto <D.20392>;
  <D.20391>:
  {
    struct MonoAssemblyBindingInfo * info;

    info = tmp->data;
    D.23154 = assembly_binding_maps_name (info, aname);
    if (D.23154 != 0) goto <D.23155>; else goto <D.23156>;
    <D.23155>:
    D.23157 = info;
    return D.23157;
    <D.23156>:
  }
  tmp = tmp->next;
  <D.20392>:
  if (tmp != 0B) goto <D.20391>; else goto <D.20393>;
  <D.20393>:
  D.23157 = 0B;
  return D.23157;
}


mono_assembly_binding_info_free (struct MonoAssemblyBindingInfo * info)
{
  char * D.23161;
  char * D.23162;

  if (info == 0B) goto <D.23159>; else goto <D.23160>;
  <D.23159>:
  return;
  <D.23160>:
  D.23161 = info->name;
  monoeg_g_free (D.23161);
  D.23162 = info->culture;
  monoeg_g_free (D.23162);
}


mono_assembly_binding_unlock ()
{
  pthread_mutex_unlock (&assembly_binding_mutex);
}


check_policy_versions (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * name)
{
  unsigned char D.23164;
  unsigned char D.23165;
  gboolean D.23168;
  unsigned char D.23169;
  struct AssemblyVersionSet * D.23172;
  int D.23173;
  struct AssemblyVersionSet * D.23176;
  int D.23177;
  int D.23180;

  D.23164 = BIT_FIELD_REF <*info, 8, 480>;
  D.23165 = D.23164 & 8;
  if (D.23165 == 0) goto <D.23166>; else goto <D.23167>;
  <D.23166>:
  D.23168 = 0;
  return D.23168;
  <D.23167>:
  D.23164 = BIT_FIELD_REF <*info, 8, 480>;
  D.23169 = D.23164 & 2;
  if (D.23169 == 0) goto <D.23170>; else goto <D.23171>;
  <D.23170>:
  D.23172 = &info->old_version_bottom;
  D.23173 = compare_versions (D.23172, name);
  if (D.23173 == 0) goto <D.23174>; else goto <D.23175>;
  <D.23174>:
  D.23168 = 1;
  return D.23168;
  <D.23175>:
  D.23168 = 0;
  return D.23168;
  <D.23171>:
  D.23176 = &info->old_version_top;
  D.23177 = compare_versions (D.23176, name);
  if (D.23177 < 0) goto <D.23178>; else goto <D.23179>;
  <D.23178>:
  D.23168 = 0;
  return D.23168;
  <D.23179>:
  D.23172 = &info->old_version_bottom;
  D.23180 = compare_versions (D.23172, name);
  if (D.23180 > 0) goto <D.23181>; else goto <D.23182>;
  <D.23181>:
  D.23168 = 0;
  return D.23168;
  <D.23182>:
  D.23168 = 1;
  return D.23168;
}


compare_versions (struct AssemblyVersionSet * v, struct MonoAssemblyName * aname)
{
  short unsigned int D.23184;
  short unsigned int D.23185;
  int D.23188;
  short unsigned int D.23191;
  short unsigned int D.23192;
  short unsigned int D.23197;
  short unsigned int D.23198;
  short unsigned int D.23203;
  short unsigned int D.23204;

  D.23184 = v->major;
  D.23185 = aname->major;
  if (D.23184 > D.23185) goto <D.23186>; else goto <D.23187>;
  <D.23186>:
  D.23188 = 1;
  return D.23188;
  <D.23187>:
  D.23184 = v->major;
  D.23185 = aname->major;
  if (D.23184 < D.23185) goto <D.23189>; else goto <D.23190>;
  <D.23189>:
  D.23188 = -1;
  return D.23188;
  <D.23190>:
  D.23191 = v->minor;
  D.23192 = aname->minor;
  if (D.23191 > D.23192) goto <D.23193>; else goto <D.23194>;
  <D.23193>:
  D.23188 = 1;
  return D.23188;
  <D.23194>:
  D.23191 = v->minor;
  D.23192 = aname->minor;
  if (D.23191 < D.23192) goto <D.23195>; else goto <D.23196>;
  <D.23195>:
  D.23188 = -1;
  return D.23188;
  <D.23196>:
  D.23197 = v->build;
  D.23198 = aname->build;
  if (D.23197 > D.23198) goto <D.23199>; else goto <D.23200>;
  <D.23199>:
  D.23188 = 1;
  return D.23188;
  <D.23200>:
  D.23197 = v->build;
  D.23198 = aname->build;
  if (D.23197 < D.23198) goto <D.23201>; else goto <D.23202>;
  <D.23201>:
  D.23188 = -1;
  return D.23188;
  <D.23202>:
  D.23203 = v->revision;
  D.23204 = aname->revision;
  if (D.23203 > D.23204) goto <D.23205>; else goto <D.23206>;
  <D.23205>:
  D.23188 = 1;
  return D.23188;
  <D.23206>:
  D.23203 = v->revision;
  D.23204 = aname->revision;
  if (D.23203 < D.23204) goto <D.23207>; else goto <D.23208>;
  <D.23207>:
  D.23188 = -1;
  return D.23188;
  <D.23208>:
  D.23188 = 0;
  return D.23188;
}


mono_assembly_bind_version (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  short unsigned int D.23210;
  short unsigned int D.23211;
  short unsigned int D.23212;
  short unsigned int D.23213;
  struct MonoAssemblyName * D.23214;

  memcpy (dest_name, aname, 60);
  D.23210 = info->new_version.major;
  dest_name->major = D.23210;
  D.23211 = info->new_version.minor;
  dest_name->minor = D.23211;
  D.23212 = info->new_version.build;
  dest_name->build = D.23212;
  D.23213 = info->new_version.revision;
  dest_name->revision = D.23213;
  D.23214 = dest_name;
  return D.23214;
}


invoke_assembly_refonly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<T1920>) (struct MonoAssemblyName *, char * *, void *) D.23216;
  void * D.23217;
  struct MonoAssembly * D.23220;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_refonly_preload_hook;
  goto <D.19960>;
  <D.19959>:
  D.23216 = hook->func;
  D.23217 = hook->user_data;
  assembly = D.23216 (aname, assemblies_path, D.23217);
  if (assembly != 0B) goto <D.23218>; else goto <D.23219>;
  <D.23218>:
  D.23220 = assembly;
  return D.23220;
  <D.23219>:
  hook = hook->next;
  <D.19960>:
  if (hook != 0B) goto <D.19959>; else goto <D.19961>;
  <D.19961>:
  D.23220 = 0B;
  return D.23220;
}


mono_assembly_load_from_gac (struct MonoAssemblyName * aname, gchar * filename, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  unsigned char D.23222;
  struct MonoAssembly * D.23225;
  const char * D.23226;
  char * D.23227;
  unsigned int D.23230;
  unsigned int D.23231;
  unsigned int len.108;
  unsigned int len.109;
  const char * D.23235;
  mono_byte[17] * D.23239;
  short unsigned int D.23240;
  int D.23241;
  short unsigned int D.23242;
  int D.23243;
  short unsigned int D.23244;
  int D.23245;
  short unsigned int D.23246;
  int D.23247;
  char * * extra_gac_paths.110;
  gchar * D.23251;
  int D.23252;
  const char * D.23256;
  struct MonoAssembly * result;
  gchar * name;
  gchar * version;
  gchar * culture;
  gchar * fullpath;
  gchar * subpath;
  gint32 len;
  gchar * * paths;
  char * pubtok;

  result = 0B;
  D.23222 = aname->public_key_token[0];
  if (D.23222 == 0) goto <D.23223>; else goto <D.23224>;
  <D.23223>:
  D.23225 = 0B;
  return D.23225;
  <D.23224>:
  D.23226 = aname->name;
  D.23227 = strstr (D.23226, ".dll");
  if (D.23227 != 0B) goto <D.23228>; else goto <D.23229>;
  <D.23228>:
  D.23230 = strlen (filename);
  D.23231 = D.23230 + 4294967292;
  len = (gint32) D.23231;
  len.108 = (unsigned int) len;
  name = monoeg_malloc (len.108);
  D.23226 = aname->name;
  len.109 = (unsigned int) len;
  strncpy (name, D.23226, len.109);
  goto <D.23234>;
  <D.23229>:
  D.23226 = aname->name;
  name = monoeg_strdup (D.23226);
  <D.23234>:
  D.23235 = aname->culture;
  if (D.23235 != 0B) goto <D.23236>; else goto <D.23237>;
  <D.23236>:
  D.23235 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.23235, -1);
  goto <D.23238>;
  <D.23237>:
  culture = monoeg_strdup ("");
  <D.23238>:
  D.23239 = &aname->public_key_token;
  pubtok = monoeg_g_ascii_strdown (D.23239, 17);
  D.23240 = aname->major;
  D.23241 = (int) D.23240;
  D.23242 = aname->minor;
  D.23243 = (int) D.23242;
  D.23244 = aname->build;
  D.23245 = (int) D.23244;
  D.23246 = aname->revision;
  D.23247 = (int) D.23246;
  version = monoeg_g_strdup_printf ("%d.%d.%d.%d_%s_%s", D.23241, D.23243, D.23245, D.23247, 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.110 = extra_gac_paths;
  if (extra_gac_paths.110 != 0B) goto <D.23249>; else goto <D.23250>;
  <D.23249>:
  paths = extra_gac_paths;
  goto <D.20479>;
  <D.20478>:
  D.23251 = *paths;
  fullpath = monoeg_g_build_path ("/", D.23251, "lib", "mono", "gac", subpath, 0B);
  D.23252 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.23252);
  monoeg_g_free (fullpath);
  paths = paths + 4;
  <D.20479>:
  if (result == 0B) goto <D.23253>; else goto <D.20480>;
  <D.23253>:
  D.23251 = *paths;
  if (D.23251 != 0B) goto <D.20478>; else goto <D.20480>;
  <D.20480>:
  <D.23250>:
  if (result != 0B) goto <D.23254>; else goto <D.23255>;
  <D.23254>:
  result->in_gac = 1;
  monoeg_g_free (subpath);
  D.23225 = result;
  return D.23225;
  <D.23255>:
  D.23256 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.23256, "mono", "gac", subpath, 0B);
  D.23252 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.23252);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.23257>; else goto <D.23258>;
  <D.23257>:
  result->in_gac = 1;
  <D.23258>:
  monoeg_g_free (subpath);
  D.23225 = result;
  return D.23225;
}


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

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


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

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


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


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

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


mono_assembly_release_gc_roots (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.23271;
  unsigned char D.23274;
  struct MonoImage * * D.23277;
  unsigned int i.111;
  unsigned int D.23279;
  struct MonoImage * * D.23280;
  struct MonoImage * D.23281;
  unsigned int i.112;
  unsigned int D.23283;

  D.23271 = assembly + 4294967295;
  if (D.23271 > 4294967293B) goto <D.23272>; else goto <D.23273>;
  <D.23272>:
  return;
  <D.23273>:
  D.23274 = assembly->dynamic;
  if (D.23274 != 0) goto <D.23275>; else goto <D.23276>;
  <D.23275>:
  {
    int i;
    struct MonoDynamicImage * dynimg;

    dynimg = assembly->image;
    i = 0;
    goto <D.20576>;
    <D.20575>:
    D.23277 = dynimg->image.modules;
    i.111 = (unsigned int) i;
    D.23279 = i.111 * 4;
    D.23280 = D.23277 + D.23279;
    D.23281 = *D.23280;
    mono_dynamic_image_release_gc_roots (D.23281);
    i = i + 1;
    <D.20576>:
    i.112 = (unsigned int) i;
    D.23283 = dynimg->image.module_count;
    if (i.112 < D.23283) goto <D.20575>; else goto <D.20577>;
    <D.20577>:
    mono_dynamic_image_release_gc_roots (dynimg);
  }
  <D.23276>:
}


mono_assembly_close_except_image_pools (struct MonoAssembly * assembly)
{
  gboolean D.23287;
  int * D.23290;
  int D.23291;
  const char * D.23294;
  struct MonoImage * D.23295;
  _Bool D.23298;
  long int D.23299;
  long int D.23300;
  struct GList * loaded_assemblies.113;
  struct GList * loaded_assemblies.114;
  _Bool D.23307;
  long int D.23308;
  long int D.23309;
  int D.23312;
  struct GSList * D.23315;
  char * D.23316;
  struct GSList * tmp;

  if (assembly == 0B) goto <D.23285>; else goto <D.23286>;
  <D.23285>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 3029, "assembly != NULL");
  D.23287 = 0;
  return D.23287;
  <D.23286>:
  if (assembly == 4294967295B) goto <D.23288>; else goto <D.23289>;
  <D.23288>:
  D.23287 = 0;
  return D.23287;
  <D.23289>:
  D.23290 = &assembly->ref_count;
  D.23291 = InterlockedDecrement (D.23290);
  if (D.23291 > 0) goto <D.23292>; else goto <D.23293>;
  <D.23292>:
  D.23287 = 0;
  return D.23287;
  <D.23293>:
  mono_profiler_assembly_event (assembly, 2);
  D.23294 = assembly->aname.name;
  mono_trace (64, 1, "Unloading assembly %s [%p].", D.23294, assembly);
  D.23295 = assembly->image;
  mono_debug_close_image (D.23295);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.23296>; else goto <D.23297>;
    <D.23296>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23297>:
    D.23298 = ret != 0;
    D.23299 = (long int) D.23298;
    D.23300 = __builtin_expect (D.23299, 0);
    if (D.23300 != 0) goto <D.23301>; else goto <D.23302>;
    <D.23301>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3044, "ret == 0");
    <D.23302>:
  }
  loaded_assemblies.113 = loaded_assemblies;
  loaded_assemblies.114 = monoeg_g_list_remove (loaded_assemblies.113, assembly);
  loaded_assemblies = loaded_assemblies.114;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.23305>; else goto <D.23306>;
    <D.23305>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23306>:
    D.23307 = ret != 0;
    D.23308 = (long int) D.23307;
    D.23309 = __builtin_expect (D.23308, 0);
    if (D.23309 != 0) goto <D.23310>; else goto <D.23311>;
    <D.23310>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3046, "ret == 0");
    <D.23311>:
  }
  D.23295 = assembly->image;
  D.23295->assembly = 0B;
  D.23295 = assembly->image;
  D.23312 = mono_image_close_except_pools (D.23295);
  if (D.23312 == 0) goto <D.23313>; else goto <D.23314>;
  <D.23313>:
  assembly->image = 0B;
  <D.23314>:
  tmp = assembly->friend_assembly_names;
  goto <D.20586>;
  <D.20585>:
  {
    struct MonoAssemblyName * fname;

    fname = tmp->data;
    mono_assembly_name_free (fname);
    monoeg_g_free (fname);
  }
  tmp = tmp->next;
  <D.20586>:
  if (tmp != 0B) goto <D.20585>; else goto <D.20587>;
  <D.20587>:
  D.23315 = assembly->friend_assembly_names;
  monoeg_g_slist_free (D.23315);
  D.23316 = assembly->basedir;
  monoeg_g_free (D.23316);
  mono_profiler_assembly_event (assembly, 3);
  D.23287 = 1;
  return D.23287;
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.23318;
  unsigned int D.23319;

  D.23319 = __sync_sub_and_fetch_4 (val, 1);
  D.23318 = (gint32) D.23319;
  return D.23318;
}


mono_assembly_close_finish (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.23321;
  _Bool D.23322;
  long int D.23323;
  long int D.23324;
  struct MonoImage * D.23327;
  unsigned char D.23330;
  const char * D.23333;

  D.23321 = assembly + 4294967295;
  D.23322 = D.23321 > 4294967293B;
  D.23323 = (long int) D.23322;
  D.23324 = __builtin_expect (D.23323, 0);
  if (D.23324 != 0) goto <D.23325>; else goto <D.23326>;
  <D.23325>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3069, "assembly && assembly != REFERENCE_MISSING");
  <D.23326>:
  D.23327 = assembly->image;
  if (D.23327 != 0B) goto <D.23328>; else goto <D.23329>;
  <D.23328>:
  D.23327 = assembly->image;
  mono_image_close_finish (D.23327);
  <D.23329>:
  D.23330 = assembly->dynamic;
  if (D.23330 != 0) goto <D.23331>; else goto <D.23332>;
  <D.23331>:
  D.23333 = assembly->aname.culture;
  monoeg_g_free (D.23333);
  goto <D.23334>;
  <D.23332>:
  monoeg_g_free (assembly);
  <D.23334>:
}


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

  D.23335 = mono_assembly_close_except_image_pools (assembly);
  if (D.23335 != 0) goto <D.23336>; else goto <D.23337>;
  <D.23336>:
  mono_assembly_close_finish (assembly);
  <D.23337>:
}


mono_assembly_load_module (struct MonoAssembly * assembly, guint32 idx)
{
  struct MonoImage * D.23338;
  struct MonoImage * D.23339;
  int idx.115;

  D.23339 = assembly->image;
  idx.115 = (int) idx;
  D.23338 = mono_image_load_file_for_image (D.23339, idx.115);
  return D.23338;
}


mono_assembly_foreach (void (*GFunc) (void *, void *) func, void * user_data)
{
  _Bool D.23344;
  long int D.23345;
  long int D.23346;
  struct GList * loaded_assemblies.116;
  _Bool D.23352;
  long int D.23353;
  long int D.23354;
  struct GList * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.23342>; else goto <D.23343>;
    <D.23342>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23343>:
    D.23344 = ret != 0;
    D.23345 = (long int) D.23344;
    D.23346 = __builtin_expect (D.23345, 0);
    if (D.23346 != 0) goto <D.23347>; else goto <D.23348>;
    <D.23347>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3110, "ret == 0");
    <D.23348>:
  }
  loaded_assemblies.116 = loaded_assemblies;
  copy = monoeg_g_list_copy (loaded_assemblies.116);
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.23350>; else goto <D.23351>;
    <D.23350>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23351>:
    D.23352 = ret != 0;
    D.23353 = (long int) D.23352;
    D.23354 = __builtin_expect (D.23353, 0);
    if (D.23354 != 0) goto <D.23355>; else goto <D.23356>;
    <D.23355>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3112, "ret == 0");
    <D.23356>:
  }
  loaded_assemblies.116 = loaded_assemblies;
  monoeg_g_list_foreach (loaded_assemblies.116, func, user_data);
  monoeg_g_list_free (copy);
}


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

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

    info = l->data;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
  }
  l = l->next;
  <D.20611>:
  if (l != 0B) goto <D.20610>; else goto <D.20612>;
  <D.20612>:
  loaded_assembly_bindings.117 = loaded_assembly_bindings;
  monoeg_g_slist_free (loaded_assembly_bindings.117);
  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.19883>;
  <D.19882>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.19883>:
  if (hook != 0B) goto <D.19882>; else goto <D.19884>;
  <D.19884>:
}


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

  hook = assembly_search_hook;
  goto <D.19923>;
  <D.19922>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.19923>:
  if (hook != 0B) goto <D.19922>; else goto <D.19924>;
  <D.19924>:
}


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

  hook = assembly_preload_hook;
  goto <D.19978>;
  <D.19977>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.19978>:
  if (hook != 0B) goto <D.19977>; else goto <D.19979>;
  <D.19979>:
  hook = assembly_refonly_preload_hook;
  goto <D.19981>;
  <D.19980>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.19981>:
  if (hook != 0B) goto <D.19980>; else goto <D.19982>;
  <D.19982>:
}


mono_assembly_cleanup_domain_bindings (guint32 domain_id)
{
  int D.23358;
  unsigned int D.23359;
  struct GSList * D.23362;
  struct GSList * D.23364;
  struct GSList * * iter;

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

    l = *iter;
    info = l->data;
    D.23358 = info->domain_id;
    D.23359 = (unsigned int) D.23358;
    if (D.23359 == domain_id) goto <D.23360>; else goto <D.23361>;
    <D.23360>:
    D.23362 = l->next;
    *iter = D.23362;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
    monoeg_g_slist_free_1 (l);
    goto <D.23363>;
    <D.23361>:
    iter = &l->next;
    <D.23363>:
  }
  <D.20620>:
  D.23364 = *iter;
  if (D.23364 != 0B) goto <D.20619>; else goto <D.20621>;
  <D.20621>:
  mono_assembly_binding_unlock ();
}


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


mono_assembly_get_main ()
{
  struct MonoAssembly * D.23365;

  D.23365 = main_assembly;
  return D.23365;
}


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

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


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


mono_assembly_has_skip_verification (struct MonoAssembly * assembly)
{
  <unnamed-unsigned:2> D.23369;
  int D.23370;
  int D.23371;
  gboolean D.23374;
  int D.23375;
  struct MonoImage * D.23376;
  unsigned int D.23377;
  unsigned int D.23378;
  unsigned int D.23381;
  unsigned int D.23384;
  const char * blob.118;
  const char * blob.119;
  unsigned int D.23387;
  sizetype len.120;
  const char * D.23391;
  int D.23392;
  <unnamed-unsigned:24> D.23395;
  int D.23396;
  struct MonoTableInfo * t;
  guint32 cols[3];
  const char * blob;
  int i;
  int len;

  try
    {
      D.23369 = assembly->skipverification;
      D.23370 = (int) D.23369;
      D.23371 = D.23370 & 2;
      if (D.23371 != 0) goto <D.23372>; else goto <D.23373>;
      <D.23372>:
      D.23369 = assembly->skipverification;
      D.23375 = (int) D.23369;
      D.23374 = D.23375 & 1;
      return D.23374;
      <D.23373>:
      D.23376 = assembly->image;
      t = &D.23376->tables[14];
      i = 0;
      goto <D.20677>;
      <D.20676>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.23377 = cols[1];
      D.23378 = D.23377 & 3;
      if (D.23378 != 2) goto <D.23379>; else goto <D.23380>;
      <D.23379>:
      // predicted unlikely by continue predictor.
      goto <D.20675>;
      <D.23380>:
      D.23381 = cols[0];
      if (D.23381 != 8) goto <D.23382>; else goto <D.23383>;
      <D.23382>:
      // predicted unlikely by continue predictor.
      goto <D.20675>;
      <D.23383>:
      D.23376 = assembly->image;
      D.23384 = cols[2];
      blob.118 = mono_metadata_blob_heap (D.23376, D.23384);
      blob = blob.118;
      blob.119 = blob;
      D.23387 = mono_metadata_decode_blob_size (blob.119, &blob);
      len = (int) D.23387;
      if (len == 0) goto <D.23388>; else goto <D.23389>;
      <D.23388>:
      // predicted unlikely by continue predictor.
      goto <D.20675>;
      <D.23389>:
      blob.119 = blob;
      blob.119 = blob;
      len.120 = (sizetype) len;
      D.23391 = blob.119 + len.120;
      D.23392 = mono_assembly_try_decode_skip_verification (blob.119, D.23391);
      if (D.23392 != 0) goto <D.23393>; else goto <D.23394>;
      <D.23393>:
      assembly->skipverification = 3;
      D.23374 = 1;
      return D.23374;
      <D.23394>:
      <D.20675>:
      i = i + 1;
      <D.20677>:
      D.23395 = t->rows;
      D.23396 = (int) D.23395;
      if (D.23396 > i) goto <D.20676>; else goto <D.20678>;
      <D.20678>:
      assembly->skipverification = 2;
      D.23374 = 0;
      return D.23374;
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
    }
}


mono_assembly_try_decode_skip_verification (const char * p, const char * endn)
{
  const char * p.121;
  char D.23400;
  int endn.122;
  int p.123;
  int D.23405;
  char * D.23408;
  _Bool D.23409;
  gboolean D.23410;
  const char * p.124;
  const char * p.125;
  char D.23413;
  unsigned int D.23416;
  unsigned int D.23417;
  int iftmp.126;
  unsigned int len.127;
  int D.23423;
  sizetype len.128;
  const char * p.129;
  unsigned int D.23427;
  sizetype params_len.130;
  unsigned int D.23431;
  int D.23432;
  int abort_decoding.131;
  const char * p.132;
  int i;
  int j;
  int num;
  int len;
  int params_len;

  p.121 = p;
  D.23400 = *p.121;
  if (D.23400 == 60) goto <D.23401>; else goto <D.23402>;
  <D.23401>:
  {
    gsize read;
    gsize written;
    char * res;

    try
      {
        p.121 = p;
        endn.122 = (int) endn;
        p.121 = p;
        p.123 = (int) p.121;
        D.23405 = endn.122 - p.123;
        res = monoeg_g_convert (p.121, D.23405, "UTF-8", "UTF-16LE", &read, &written, 0B);
        if (res != 0B) goto <D.23406>; else goto <D.23407>;
        <D.23406>:
        {
          gboolean found;

          D.23408 = strstr (res, "\"SkipVerification\"");
          D.23409 = D.23408 != 0B;
          found = (gboolean) D.23409;
          monoeg_g_free (res);
          D.23410 = found;
          return D.23410;
        }
        <D.23407>:
        D.23410 = 0;
        return D.23410;
      }
    finally
      {
        read = {CLOBBER};
        written = {CLOBBER};
      }
  }
  <D.23402>:
  p.121 = p;
  p.124 = p.121;
  p.125 = p.124 + 1;
  p = p.125;
  D.23413 = *p.124;
  if (D.23413 != 46) goto <D.23414>; else goto <D.23415>;
  <D.23414>:
  D.23410 = 0;
  return D.23410;
  <D.23415>:
  p.121 = p;
  D.23416 = mono_metadata_decode_value (p.121, &p);
  num = (int) D.23416;
  i = 0;
  goto <D.20665>;
  <D.20664>:
  {
    gboolean is_valid;
    gboolean abort_decoding;

    try
      {
        is_valid = 0;
        abort_decoding = 0;
        p.121 = p;
        D.23417 = mono_metadata_decode_value (p.121, &p);
        len = (int) D.23417;
        len.127 = (unsigned int) len;
        if (len.127 > 54) goto <D.23422>; else goto <D.23419>;
        <D.23422>:
        p.121 = p;
        D.23423 = memcmp (p.121, "System.Security.Permissions.SecurityPermissionAttribute", 55);
        if (D.23423 == 0) goto <D.23424>; else goto <D.23419>;
        <D.23424>:
        iftmp.126 = 1;
        goto <D.23420>;
        <D.23419>:
        iftmp.126 = 0;
        <D.23420>:
        is_valid = iftmp.126;
        p.121 = p;
        len.128 = (sizetype) len;
        p.129 = p.121 + len.128;
        p = p.129;
        p.121 = p;
        D.23427 = mono_metadata_decode_value (p.121, &p);
        params_len = (int) D.23427;
        if (is_valid != 0) goto <D.23428>; else goto <D.23429>;
        <D.23428>:
        {
          const char * params_end;

          p.121 = p;
          params_len.130 = (sizetype) params_len;
          params_end = p.121 + params_len.130;
          p.121 = p;
          D.23431 = mono_metadata_decode_value (p.121, &p);
          len = (int) D.23431;
          j = 0;
          goto <D.20663>;
          <D.20662>:
          p.121 = p;
          D.23432 = mono_assembly_try_decode_skip_verification_param (p.121, &p, &abort_decoding);
          if (D.23432 != 0) goto <D.23433>; else goto <D.23434>;
          <D.23433>:
          D.23410 = 1;
          return D.23410;
          <D.23434>:
          abort_decoding.131 = abort_decoding;
          if (abort_decoding.131 != 0) goto <D.20661>; else goto <D.23436>;
          <D.23436>:
          j = j + 1;
          <D.20663>:
          if (j < len) goto <D.20662>; else goto <D.20661>;
          <D.20661>:
          p = params_end;
        }
        goto <D.23437>;
        <D.23429>:
        p.121 = p;
        params_len.130 = (sizetype) params_len;
        p.132 = p.121 + params_len.130;
        p = p.132;
        <D.23437>:
      }
    finally
      {
        abort_decoding = {CLOBBER};
      }
  }
  i = i + 1;
  <D.20665>:
  if (i < num) goto <D.20664>; else goto <D.20666>;
  <D.20666>:
  D.23410 = 0;
  return D.23410;
}


mono_assembly_try_decode_skip_verification_param (const char * p, const char * * resp, gboolean * abort_decoding)
{
  const char * p.133;
  const char * p.134;
  const char * p.135;
  char D.23446;
  int D.23447;
  gboolean D.23448;
  const char * p.136;
  const char * p.137;
  char D.23451;
  unsigned int D.23454;
  unsigned int len.138;
  int D.23458;
  sizetype len.139;
  const char * p.140;
  char D.23463;
  sizetype D.23464;
  const char * p.141;
  int len;

  p.133 = p;
  p.134 = p.133;
  p.135 = p.134 + 1;
  p = p.135;
  D.23446 = *p.134;
  D.23447 = (int) D.23446;
  switch (D.23447) <default: <D.20644>, case 83: <D.20643>, case 84: <D.20641>>
  <D.20641>:
  goto <D.20642>;
  <D.20643>:
  <D.20644>:
  *abort_decoding = 1;
  D.23448 = 0;
  return D.23448;
  <D.20642>:
  p.133 = p;
  p.136 = p.133;
  p.137 = p.136 + 1;
  p = p.137;
  D.23451 = *p.136;
  if (D.23451 != 2) goto <D.23452>; else goto <D.23453>;
  <D.23452>:
  *abort_decoding = 1;
  D.23448 = 0;
  return D.23448;
  <D.23453>:
  p.133 = p;
  D.23454 = mono_metadata_decode_value (p.133, &p);
  len = (int) D.23454;
  len.138 = (unsigned int) len;
  if (len.138 > 15) goto <D.23456>; else goto <D.23457>;
  <D.23456>:
  p.133 = p;
  D.23458 = memcmp (p.133, "SkipVerification", 16);
  if (D.23458 == 0) goto <D.23459>; else goto <D.23460>;
  <D.23459>:
  p.133 = p;
  len.139 = (sizetype) len;
  p.140 = p.133 + len.139;
  p = p.140;
  p.133 = p;
  D.23463 = *p.133;
  D.23448 = (gboolean) D.23463;
  return D.23448;
  <D.23460>:
  <D.23457>:
  p.133 = p;
  len.139 = (sizetype) len;
  D.23464 = len.139 + 1;
  p.141 = p.133 + D.23464;
  p = p.141;
  p.133 = p;
  *resp = p.133;
  D.23448 = 0;
  return D.23448;
}