mono_public_tokens_are_equal (const unsigned char * pubt1, const unsigned char * pubt2)
{
  gboolean D.18111;
  int D.18112;
  _Bool D.18113;

  D.18112 = memcmp (pubt1, pubt2, 16);
  D.18113 = D.18112 == 0;
  D.18111 = (gboolean) D.18113;
  return D.18111;
}


mono_set_assemblies_path (const char * path)
{
  char * * assemblies_path.0;
  char * D.18118;
  char D.18119;
  char * * dest.1;
  const gchar * D.18123;
  int D.18128;
  char * * splitted;
  char * * dest;

  splitted = monoeg_g_strsplit (path, ":", 1000);
  assemblies_path.0 = assemblies_path;
  if (assemblies_path.0 != 0B) goto <D.18116>; else goto <D.18117>;
  <D.18116>:
  assemblies_path.0 = assemblies_path;
  monoeg_g_strfreev (assemblies_path.0);
  <D.18117>:
  dest = splitted;
  assemblies_path = dest;
  goto <D.16955>;
  <D.16954>:
  D.18118 = *splitted;
  D.18119 = *D.18118;
  if (D.18119 != 0) goto <D.18120>; else goto <D.18121>;
  <D.18120>:
  dest.1 = dest;
  dest = dest.1 + 4;
  D.18118 = *splitted;
  *dest.1 = D.18118;
  <D.18121>:
  splitted = splitted + 4;
  <D.16955>:
  D.18118 = *splitted;
  if (D.18118 != 0B) goto <D.16954>; else goto <D.16956>;
  <D.16956>:
  D.18118 = *splitted;
  *dest = D.18118;
  D.18123 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.18123 == 0B) goto <D.18124>; else goto <D.18125>;
  <D.18124>:
  return;
  <D.18125>:
  splitted = assemblies_path;
  goto <D.16958>;
  <D.16957>:
  D.18118 = *splitted;
  D.18119 = *D.18118;
  if (D.18119 != 0) goto <D.18126>; else goto <D.18127>;
  <D.18126>:
  D.18118 = *splitted;
  D.18128 = monoeg_g_file_test (D.18118, 4);
  if (D.18128 == 0) goto <D.18129>; else goto <D.18130>;
  <D.18129>:
  D.18118 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_PATH doesn\'t exist or has wrong permissions.", D.18118);
  <D.18130>:
  <D.18127>:
  splitted = splitted + 4;
  <D.16958>:
  D.18118 = *splitted;
  if (D.18118 != 0B) goto <D.16957>; else goto <D.16959>;
  <D.16959>:
}


mono_assembly_names_equal (struct MonoAssemblyName * l, struct MonoAssemblyName * r)
{
  const char * D.18134;
  const char * D.18136;
  mono_bool D.18137;
  int D.17031;
  const char * D.18140;
  const char * D.18143;
  int D.17040;
  unsigned int D.18150;
  unsigned int D.18151;
  unsigned int D.18152;
  unsigned int D.18153;
  unsigned int D.18155;
  unsigned int D.18156;
  unsigned int D.18157;
  unsigned int D.18158;
  unsigned char D.18166;
  unsigned char D.18168;
  mono_byte[17] * D.18169;
  mono_byte[17] * D.18170;
  int D.18171;

  D.18134 = l->name;
  if (D.18134 == 0B) goto <D.18132>; else goto <D.18135>;
  <D.18135>:
  D.18136 = r->name;
  if (D.18136 == 0B) goto <D.18132>; else goto <D.18133>;
  <D.18132>:
  D.18137 = 0;
  return D.18137;
  <D.18133>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.18136 = r->name;
    D.18134 = l->name;
    D.17031 = __builtin_strcmp (D.18134, D.18136);
  }
  if (D.17031 != 0) goto <D.18138>; else goto <D.18139>;
  <D.18138>:
  D.18137 = 0;
  return D.18137;
  <D.18139>:
  D.18140 = l->culture;
  if (D.18140 != 0B) goto <D.18141>; else goto <D.18142>;
  <D.18141>:
  D.18143 = r->culture;
  if (D.18143 != 0B) goto <D.18144>; else goto <D.18145>;
  <D.18144>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.18143 = r->culture;
    D.18140 = l->culture;
    D.17040 = __builtin_strcmp (D.18140, D.18143);
  }
  if (D.17040 != 0) goto <D.18146>; else goto <D.18147>;
  <D.18146>:
  D.18137 = 0;
  return D.18137;
  <D.18147>:
  <D.18145>:
  <D.18142>:
  D.18150 = BIT_FIELD_REF <*l, 32, 384>;
  D.18151 = D.18150;
  D.18152 = BIT_FIELD_REF <*r, 32, 384>;
  D.18153 = D.18152;
  if (D.18151 != D.18153) goto <D.18148>; else goto <D.18154>;
  <D.18154>:
  D.18155 = BIT_FIELD_REF <*l, 32, 416>;
  D.18156 = D.18155;
  D.18157 = BIT_FIELD_REF <*r, 32, 416>;
  D.18158 = D.18157;
  if (D.18156 != D.18158) goto <D.18148>; else goto <D.18149>;
  <D.18148>:
  D.18150 = BIT_FIELD_REF <*l, 32, 384>;
  D.18151 = D.18150;
  if (D.18151 != 0) goto <D.18161>; else goto <D.18162>;
  <D.18162>:
  D.18155 = BIT_FIELD_REF <*l, 32, 416>;
  D.18156 = D.18155;
  if (D.18156 != 0) goto <D.18161>; else goto <D.18160>;
  <D.18161>:
  D.18152 = BIT_FIELD_REF <*r, 32, 384>;
  D.18153 = D.18152;
  if (D.18153 != 0) goto <D.18159>; else goto <D.18163>;
  <D.18163>:
  D.18157 = BIT_FIELD_REF <*r, 32, 416>;
  D.18158 = D.18157;
  if (D.18158 != 0) goto <D.18159>; else goto <D.18160>;
  <D.18159>:
  D.18137 = 0;
  return D.18137;
  <D.18160>:
  <D.18149>:
  D.18166 = l->public_key_token[0];
  if (D.18166 == 0) goto <D.18164>; else goto <D.18167>;
  <D.18167>:
  D.18168 = r->public_key_token[0];
  if (D.18168 == 0) goto <D.18164>; else goto <D.18165>;
  <D.18164>:
  D.18137 = 1;
  return D.18137;
  <D.18165>:
  D.18169 = &r->public_key_token;
  D.18170 = &l->public_key_token;
  D.18171 = mono_public_tokens_are_equal (D.18170, D.18169);
  if (D.18171 == 0) goto <D.18172>; else goto <D.18173>;
  <D.18172>:
  D.18137 = 0;
  return D.18137;
  <D.18173>:
  D.18137 = 1;
  return D.18137;
}


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

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


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

  if (str != 0B) goto <D.18176>; else goto <D.18177>;
  <D.18176>:
  D.18178 = __strdup (str);
  return D.18178;
  <D.18177>:
  D.18178 = 0B;
  return D.18178;
}


mono_assembly_getrootdir ()
{
  const char * D.18180;

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


mono_set_dirs (const char * assembly_dir, const char * config_dir)
{
  if (assembly_dir == 0B) goto <D.18182>; else goto <D.18183>;
  <D.18182>:
  assembly_dir = "/usr/lib";
  <D.18183>:
  if (config_dir == 0B) goto <D.18184>; else goto <D.18185>;
  <D.18184>:
  config_dir = "/etc";
  <D.18185>:
  mono_assembly_setrootdir (assembly_dir);
  mono_set_config_dir (config_dir);
}


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

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


readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  unsigned int D.18194;
  int D.18197;
  ssize_t D.18200;
  unsigned int D.18201;
  unsigned int D.18202;
  unsigned int D.18205;

  D.18194 = __builtin_object_size (__buf, 1);
  if (D.18194 != 4294967295) goto <D.18195>; else goto <D.18196>;
  <D.18195>:
  D.18197 = __builtin_constant_p (__len);
  if (D.18197 == 0) goto <D.18198>; else goto <D.18199>;
  <D.18198>:
  D.18201 = __builtin_object_size (__buf, 1);
  D.18200 = __readlink_chk (__path, __buf, __len, D.18201);
  return D.18200;
  <D.18199>:
  D.18202 = __builtin_object_size (__buf, 1);
  if (D.18202 < __len) goto <D.18203>; else goto <D.18204>;
  <D.18203>:
  D.18205 = __builtin_object_size (__buf, 1);
  D.18200 = __readlink_chk_warn (__path, __buf, __len, D.18205);
  return D.18200;
  <D.18204>:
  <D.18196>:
  D.18200 = __readlink_alias (__path, __buf, __len);
  return D.18200;
}


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

  try
    {
      D.18209 = strncmp (exe, "/usr/bin/", 9);
      if (D.18209 == 0) goto <D.18207>; else goto <D.18210>;
      <D.18210>:
      base = compute_base (exe);
      if (base == 0B) goto <D.18207>; else goto <D.18208>;
      <D.18207>:
      fallback ();
      return;
      <D.18208>:
      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.18211 = stat (mono, &buf);
      if (D.18211 == -1) goto <D.18212>; else goto <D.18213>;
      <D.18212>:
      fallback ();
      goto <D.18214>;
      <D.18213>:
      mono_set_dirs (lib, config);
      <D.18214>:
      monoeg_g_free (config);
      monoeg_g_free (lib);
      monoeg_g_free (mono);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


compute_base (char * path)
{
  char * D.18220;
  int D.17075;
  int iftmp.2;
  int D.17074;
  const char[6] * D.18224;
  unsigned char D.18225;
  int D.18226;
  unsigned char D.18227;
  int D.18228;
  _Bool D.18229;
  _Bool D.18230;
  _Bool D.18231;
  const unsigned char * D.18234;
  unsigned char D.18235;
  int D.18236;
  const unsigned char * D.18237;
  unsigned char D.18238;
  int D.18239;
  _Bool D.18240;
  _Bool D.18241;
  const unsigned char * D.18244;
  unsigned char D.18245;
  int D.18246;
  const unsigned char * D.18247;
  unsigned char D.18248;
  int D.18249;
  _Bool D.18250;
  _Bool D.18251;
  const unsigned char * D.18254;
  unsigned char D.18255;
  int D.18256;
  const unsigned char * D.18257;
  unsigned char D.18258;
  int D.18259;
  int D.17084;
  int iftmp.3;
  int D.17083;
  const char[11] * D.18266;
  unsigned char D.18267;
  int D.18268;
  unsigned char D.18269;
  int D.18270;
  _Bool D.18271;
  _Bool D.18272;
  _Bool D.18273;
  const unsigned char * D.18276;
  unsigned char D.18277;
  int D.18278;
  const unsigned char * D.18279;
  unsigned char D.18280;
  int D.18281;
  _Bool D.18282;
  _Bool D.18283;
  const unsigned char * D.18286;
  unsigned char D.18287;
  int D.18288;
  const unsigned char * D.18289;
  unsigned char D.18290;
  int D.18291;
  _Bool D.18292;
  _Bool D.18293;
  const unsigned char * D.18296;
  unsigned char D.18297;
  int D.18298;
  const unsigned char * D.18299;
  unsigned char D.18300;
  int D.18301;
  int D.17093;
  int iftmp.4;
  int D.17092;
  const char[8] * D.18308;
  unsigned char D.18309;
  int D.18310;
  unsigned char D.18311;
  int D.18312;
  _Bool D.18313;
  _Bool D.18314;
  _Bool D.18315;
  const unsigned char * D.18318;
  unsigned char D.18319;
  int D.18320;
  const unsigned char * D.18321;
  unsigned char D.18322;
  int D.18323;
  _Bool D.18324;
  _Bool D.18325;
  const unsigned char * D.18328;
  unsigned char D.18329;
  int D.18330;
  const unsigned char * D.18331;
  unsigned char D.18332;
  int D.18333;
  _Bool D.18334;
  _Bool D.18335;
  const unsigned char * D.18338;
  unsigned char D.18339;
  int D.18340;
  const unsigned char * D.18341;
  unsigned char D.18342;
  int D.18343;
  int D.17102;
  int iftmp.5;
  int D.17101;
  const char[9] * D.18350;
  unsigned char D.18351;
  int D.18352;
  unsigned char D.18353;
  int D.18354;
  _Bool D.18355;
  _Bool D.18356;
  _Bool D.18357;
  const unsigned char * D.18360;
  unsigned char D.18361;
  int D.18362;
  const unsigned char * D.18363;
  unsigned char D.18364;
  int D.18365;
  _Bool D.18366;
  _Bool D.18367;
  const unsigned char * D.18370;
  unsigned char D.18371;
  int D.18372;
  const unsigned char * D.18373;
  unsigned char D.18374;
  int D.18375;
  _Bool D.18376;
  _Bool D.18377;
  const unsigned char * D.18380;
  unsigned char D.18381;
  int D.18382;
  const unsigned char * D.18383;
  unsigned char D.18384;
  int D.18385;
  int D.17111;
  int iftmp.6;
  int D.17110;
  const char[6] * D.18392;
  unsigned char D.18393;
  int D.18394;
  unsigned char D.18395;
  int D.18396;
  _Bool D.18397;
  _Bool D.18398;
  _Bool D.18399;
  const unsigned char * D.18402;
  unsigned char D.18403;
  int D.18404;
  const unsigned char * D.18405;
  unsigned char D.18406;
  int D.18407;
  _Bool D.18408;
  _Bool D.18409;
  const unsigned char * D.18412;
  unsigned char D.18413;
  int D.18414;
  const unsigned char * D.18415;
  unsigned char D.18416;
  int D.18417;
  _Bool D.18418;
  _Bool D.18419;
  const unsigned char * D.18422;
  unsigned char D.18423;
  int D.18424;
  const unsigned char * D.18425;
  unsigned char D.18426;
  int D.18427;
  int D.17120;
  int iftmp.7;
  int D.17119;
  const char[10] * D.18434;
  unsigned char D.18435;
  int D.18436;
  unsigned char D.18437;
  int D.18438;
  _Bool D.18439;
  _Bool D.18440;
  _Bool D.18441;
  const unsigned char * D.18444;
  unsigned char D.18445;
  int D.18446;
  const unsigned char * D.18447;
  unsigned char D.18448;
  int D.18449;
  _Bool D.18450;
  _Bool D.18451;
  const unsigned char * D.18454;
  unsigned char D.18455;
  int D.18456;
  const unsigned char * D.18457;
  unsigned char D.18458;
  int D.18459;
  _Bool D.18460;
  _Bool D.18461;
  const unsigned char * D.18464;
  unsigned char D.18465;
  int D.18466;
  const unsigned char * D.18467;
  unsigned char D.18468;
  int D.18469;
  int D.17129;
  int iftmp.8;
  int D.17128;
  const char[5] * D.18478;
  unsigned char D.18479;
  int D.18480;
  unsigned char D.18481;
  int D.18482;
  _Bool D.18483;
  _Bool D.18484;
  _Bool D.18485;
  const unsigned char * D.18488;
  unsigned char D.18489;
  int D.18490;
  const unsigned char * D.18491;
  unsigned char D.18492;
  int D.18493;
  _Bool D.18494;
  _Bool D.18495;
  const unsigned char * D.18498;
  unsigned char D.18499;
  int D.18500;
  const unsigned char * D.18501;
  unsigned char D.18502;
  int D.18503;
  _Bool D.18504;
  _Bool D.18505;
  const unsigned char * D.18508;
  unsigned char D.18509;
  int D.18510;
  const unsigned char * D.18511;
  unsigned char D.18512;
  int D.18513;
  char * p;

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

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

      __s2 = p;
      D.18224 = "/mono";
      D.18225 = MEM[(const unsigned char *)D.18224];
      D.18226 = (int) D.18225;
      D.18227 = *__s2;
      D.18228 = (int) D.18227;
      __result = D.18226 - D.18228;
      {
        D.18229 = __s2_len != 0;
        D.18230 = __result == 0;
        D.18231 = D.18229 & D.18230;
        if (D.18231 != 0) goto <D.18232>; else goto <D.18233>;
        <D.18232>:
        D.18234 = &MEM[(void *)"/mono" + 1B];
        D.18235 = *D.18234;
        D.18236 = (int) D.18235;
        D.18237 = __s2 + 1;
        D.18238 = *D.18237;
        D.18239 = (int) D.18238;
        __result = D.18236 - D.18239;
        D.18240 = __s2_len > 1;
        D.18230 = __result == 0;
        D.18241 = D.18240 & D.18230;
        if (D.18241 != 0) goto <D.18242>; else goto <D.18243>;
        <D.18242>:
        D.18244 = &MEM[(void *)"/mono" + 2B];
        D.18245 = *D.18244;
        D.18246 = (int) D.18245;
        D.18247 = __s2 + 2;
        D.18248 = *D.18247;
        D.18249 = (int) D.18248;
        __result = D.18246 - D.18249;
        D.18250 = __s2_len > 2;
        D.18230 = __result == 0;
        D.18251 = D.18250 & D.18230;
        if (D.18251 != 0) goto <D.18252>; else goto <D.18253>;
        <D.18252>:
        D.18254 = &MEM[(void *)"/mono" + 3B];
        D.18255 = *D.18254;
        D.18256 = (int) D.18255;
        D.18257 = __s2 + 3;
        D.18258 = *D.18257;
        D.18259 = (int) D.18258;
        __result = D.18256 - D.18259;
        <D.18253>:
        <D.18243>:
        <D.18233>:
      }
      D.17074 = __result;
    }
    iftmp.2 = -D.17074;
    goto <D.18260>;
    <D.18223>:
    iftmp.2 = __builtin_strcmp (p, "/mono");
    <D.18260>:
    D.17075 = iftmp.2;
  }
  if (D.17075 != 0) goto <D.18261>; else goto <D.18262>;
  <D.18261>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.18266 = "/mono-sgen";
      D.18267 = MEM[(const unsigned char *)D.18266];
      D.18268 = (int) D.18267;
      D.18269 = *__s2;
      D.18270 = (int) D.18269;
      __result = D.18268 - D.18270;
      {
        D.18271 = __s2_len != 0;
        D.18272 = __result == 0;
        D.18273 = D.18271 & D.18272;
        if (D.18273 != 0) goto <D.18274>; else goto <D.18275>;
        <D.18274>:
        D.18276 = &MEM[(void *)"/mono-sgen" + 1B];
        D.18277 = *D.18276;
        D.18278 = (int) D.18277;
        D.18279 = __s2 + 1;
        D.18280 = *D.18279;
        D.18281 = (int) D.18280;
        __result = D.18278 - D.18281;
        D.18282 = __s2_len > 1;
        D.18272 = __result == 0;
        D.18283 = D.18282 & D.18272;
        if (D.18283 != 0) goto <D.18284>; else goto <D.18285>;
        <D.18284>:
        D.18286 = &MEM[(void *)"/mono-sgen" + 2B];
        D.18287 = *D.18286;
        D.18288 = (int) D.18287;
        D.18289 = __s2 + 2;
        D.18290 = *D.18289;
        D.18291 = (int) D.18290;
        __result = D.18288 - D.18291;
        D.18292 = __s2_len > 2;
        D.18272 = __result == 0;
        D.18293 = D.18292 & D.18272;
        if (D.18293 != 0) goto <D.18294>; else goto <D.18295>;
        <D.18294>:
        D.18296 = &MEM[(void *)"/mono-sgen" + 3B];
        D.18297 = *D.18296;
        D.18298 = (int) D.18297;
        D.18299 = __s2 + 3;
        D.18300 = *D.18299;
        D.18301 = (int) D.18300;
        __result = D.18298 - D.18301;
        <D.18295>:
        <D.18285>:
        <D.18275>:
      }
      D.17083 = __result;
    }
    iftmp.3 = -D.17083;
    goto <D.18302>;
    <D.18265>:
    iftmp.3 = __builtin_strcmp (p, "/mono-sgen");
    <D.18302>:
    D.17084 = iftmp.3;
  }
  if (D.17084 != 0) goto <D.18303>; else goto <D.18304>;
  <D.18303>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.18308 = "/pedump";
      D.18309 = MEM[(const unsigned char *)D.18308];
      D.18310 = (int) D.18309;
      D.18311 = *__s2;
      D.18312 = (int) D.18311;
      __result = D.18310 - D.18312;
      {
        D.18313 = __s2_len != 0;
        D.18314 = __result == 0;
        D.18315 = D.18313 & D.18314;
        if (D.18315 != 0) goto <D.18316>; else goto <D.18317>;
        <D.18316>:
        D.18318 = &MEM[(void *)"/pedump" + 1B];
        D.18319 = *D.18318;
        D.18320 = (int) D.18319;
        D.18321 = __s2 + 1;
        D.18322 = *D.18321;
        D.18323 = (int) D.18322;
        __result = D.18320 - D.18323;
        D.18324 = __s2_len > 1;
        D.18314 = __result == 0;
        D.18325 = D.18324 & D.18314;
        if (D.18325 != 0) goto <D.18326>; else goto <D.18327>;
        <D.18326>:
        D.18328 = &MEM[(void *)"/pedump" + 2B];
        D.18329 = *D.18328;
        D.18330 = (int) D.18329;
        D.18331 = __s2 + 2;
        D.18332 = *D.18331;
        D.18333 = (int) D.18332;
        __result = D.18330 - D.18333;
        D.18334 = __s2_len > 2;
        D.18314 = __result == 0;
        D.18335 = D.18334 & D.18314;
        if (D.18335 != 0) goto <D.18336>; else goto <D.18337>;
        <D.18336>:
        D.18338 = &MEM[(void *)"/pedump" + 3B];
        D.18339 = *D.18338;
        D.18340 = (int) D.18339;
        D.18341 = __s2 + 3;
        D.18342 = *D.18341;
        D.18343 = (int) D.18342;
        __result = D.18340 - D.18343;
        <D.18337>:
        <D.18327>:
        <D.18317>:
      }
      D.17092 = __result;
    }
    iftmp.4 = -D.17092;
    goto <D.18344>;
    <D.18307>:
    iftmp.4 = __builtin_strcmp (p, "/pedump");
    <D.18344>:
    D.17093 = iftmp.4;
  }
  if (D.17093 != 0) goto <D.18345>; else goto <D.18346>;
  <D.18345>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.18350 = "/monodis";
      D.18351 = MEM[(const unsigned char *)D.18350];
      D.18352 = (int) D.18351;
      D.18353 = *__s2;
      D.18354 = (int) D.18353;
      __result = D.18352 - D.18354;
      {
        D.18355 = __s2_len != 0;
        D.18356 = __result == 0;
        D.18357 = D.18355 & D.18356;
        if (D.18357 != 0) goto <D.18358>; else goto <D.18359>;
        <D.18358>:
        D.18360 = &MEM[(void *)"/monodis" + 1B];
        D.18361 = *D.18360;
        D.18362 = (int) D.18361;
        D.18363 = __s2 + 1;
        D.18364 = *D.18363;
        D.18365 = (int) D.18364;
        __result = D.18362 - D.18365;
        D.18366 = __s2_len > 1;
        D.18356 = __result == 0;
        D.18367 = D.18366 & D.18356;
        if (D.18367 != 0) goto <D.18368>; else goto <D.18369>;
        <D.18368>:
        D.18370 = &MEM[(void *)"/monodis" + 2B];
        D.18371 = *D.18370;
        D.18372 = (int) D.18371;
        D.18373 = __s2 + 2;
        D.18374 = *D.18373;
        D.18375 = (int) D.18374;
        __result = D.18372 - D.18375;
        D.18376 = __s2_len > 2;
        D.18356 = __result == 0;
        D.18377 = D.18376 & D.18356;
        if (D.18377 != 0) goto <D.18378>; else goto <D.18379>;
        <D.18378>:
        D.18380 = &MEM[(void *)"/monodis" + 3B];
        D.18381 = *D.18380;
        D.18382 = (int) D.18381;
        D.18383 = __s2 + 3;
        D.18384 = *D.18383;
        D.18385 = (int) D.18384;
        __result = D.18382 - D.18385;
        <D.18379>:
        <D.18369>:
        <D.18359>:
      }
      D.17101 = __result;
    }
    iftmp.5 = -D.17101;
    goto <D.18386>;
    <D.18349>:
    iftmp.5 = __builtin_strcmp (p, "/monodis");
    <D.18386>:
    D.17102 = iftmp.5;
  }
  if (D.17102 != 0) goto <D.18387>; else goto <D.18388>;
  <D.18387>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.18392 = "/mint";
      D.18393 = MEM[(const unsigned char *)D.18392];
      D.18394 = (int) D.18393;
      D.18395 = *__s2;
      D.18396 = (int) D.18395;
      __result = D.18394 - D.18396;
      {
        D.18397 = __s2_len != 0;
        D.18398 = __result == 0;
        D.18399 = D.18397 & D.18398;
        if (D.18399 != 0) goto <D.18400>; else goto <D.18401>;
        <D.18400>:
        D.18402 = &MEM[(void *)"/mint" + 1B];
        D.18403 = *D.18402;
        D.18404 = (int) D.18403;
        D.18405 = __s2 + 1;
        D.18406 = *D.18405;
        D.18407 = (int) D.18406;
        __result = D.18404 - D.18407;
        D.18408 = __s2_len > 1;
        D.18398 = __result == 0;
        D.18409 = D.18408 & D.18398;
        if (D.18409 != 0) goto <D.18410>; else goto <D.18411>;
        <D.18410>:
        D.18412 = &MEM[(void *)"/mint" + 2B];
        D.18413 = *D.18412;
        D.18414 = (int) D.18413;
        D.18415 = __s2 + 2;
        D.18416 = *D.18415;
        D.18417 = (int) D.18416;
        __result = D.18414 - D.18417;
        D.18418 = __s2_len > 2;
        D.18398 = __result == 0;
        D.18419 = D.18418 & D.18398;
        if (D.18419 != 0) goto <D.18420>; else goto <D.18421>;
        <D.18420>:
        D.18422 = &MEM[(void *)"/mint" + 3B];
        D.18423 = *D.18422;
        D.18424 = (int) D.18423;
        D.18425 = __s2 + 3;
        D.18426 = *D.18425;
        D.18427 = (int) D.18426;
        __result = D.18424 - D.18427;
        <D.18421>:
        <D.18411>:
        <D.18401>:
      }
      D.17110 = __result;
    }
    iftmp.6 = -D.17110;
    goto <D.18428>;
    <D.18391>:
    iftmp.6 = __builtin_strcmp (p, "/mint");
    <D.18428>:
    D.17111 = iftmp.6;
  }
  if (D.17111 != 0) goto <D.18429>; else goto <D.18430>;
  <D.18429>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.18434 = "/monodiet";
      D.18435 = MEM[(const unsigned char *)D.18434];
      D.18436 = (int) D.18435;
      D.18437 = *__s2;
      D.18438 = (int) D.18437;
      __result = D.18436 - D.18438;
      {
        D.18439 = __s2_len != 0;
        D.18440 = __result == 0;
        D.18441 = D.18439 & D.18440;
        if (D.18441 != 0) goto <D.18442>; else goto <D.18443>;
        <D.18442>:
        D.18444 = &MEM[(void *)"/monodiet" + 1B];
        D.18445 = *D.18444;
        D.18446 = (int) D.18445;
        D.18447 = __s2 + 1;
        D.18448 = *D.18447;
        D.18449 = (int) D.18448;
        __result = D.18446 - D.18449;
        D.18450 = __s2_len > 1;
        D.18440 = __result == 0;
        D.18451 = D.18450 & D.18440;
        if (D.18451 != 0) goto <D.18452>; else goto <D.18453>;
        <D.18452>:
        D.18454 = &MEM[(void *)"/monodiet" + 2B];
        D.18455 = *D.18454;
        D.18456 = (int) D.18455;
        D.18457 = __s2 + 2;
        D.18458 = *D.18457;
        D.18459 = (int) D.18458;
        __result = D.18456 - D.18459;
        D.18460 = __s2_len > 2;
        D.18440 = __result == 0;
        D.18461 = D.18460 & D.18440;
        if (D.18461 != 0) goto <D.18462>; else goto <D.18463>;
        <D.18462>:
        D.18464 = &MEM[(void *)"/monodiet" + 3B];
        D.18465 = *D.18464;
        D.18466 = (int) D.18465;
        D.18467 = __s2 + 3;
        D.18468 = *D.18467;
        D.18469 = (int) D.18468;
        __result = D.18466 - D.18469;
        <D.18463>:
        <D.18453>:
        <D.18443>:
      }
      D.17119 = __result;
    }
    iftmp.7 = -D.17119;
    goto <D.18470>;
    <D.18433>:
    iftmp.7 = __builtin_strcmp (p, "/monodiet");
    <D.18470>:
    D.17120 = iftmp.7;
  }
  if (D.17120 != 0) goto <D.18471>; else goto <D.18472>;
  <D.18471>:
  D.18220 = 0B;
  return D.18220;
  <D.18472>:
  <D.18430>:
  <D.18388>:
  <D.18346>:
  <D.18304>:
  <D.18262>:
  *p = 0;
  p = strrchr (path, 47);
  if (p == 0B) goto <D.18473>; else goto <D.18474>;
  <D.18473>:
  D.18220 = 0B;
  return D.18220;
  <D.18474>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = p;
      D.18478 = "/bin";
      D.18479 = MEM[(const unsigned char *)D.18478];
      D.18480 = (int) D.18479;
      D.18481 = *__s2;
      D.18482 = (int) D.18481;
      __result = D.18480 - D.18482;
      {
        D.18483 = __s2_len != 0;
        D.18484 = __result == 0;
        D.18485 = D.18483 & D.18484;
        if (D.18485 != 0) goto <D.18486>; else goto <D.18487>;
        <D.18486>:
        D.18488 = &MEM[(void *)"/bin" + 1B];
        D.18489 = *D.18488;
        D.18490 = (int) D.18489;
        D.18491 = __s2 + 1;
        D.18492 = *D.18491;
        D.18493 = (int) D.18492;
        __result = D.18490 - D.18493;
        D.18494 = __s2_len > 1;
        D.18484 = __result == 0;
        D.18495 = D.18494 & D.18484;
        if (D.18495 != 0) goto <D.18496>; else goto <D.18497>;
        <D.18496>:
        D.18498 = &MEM[(void *)"/bin" + 2B];
        D.18499 = *D.18498;
        D.18500 = (int) D.18499;
        D.18501 = __s2 + 2;
        D.18502 = *D.18501;
        D.18503 = (int) D.18502;
        __result = D.18500 - D.18503;
        D.18504 = __s2_len > 2;
        D.18484 = __result == 0;
        D.18505 = D.18504 & D.18484;
        if (D.18505 != 0) goto <D.18506>; else goto <D.18507>;
        <D.18506>:
        D.18508 = &MEM[(void *)"/bin" + 3B];
        D.18509 = *D.18508;
        D.18510 = (int) D.18509;
        D.18511 = __s2 + 3;
        D.18512 = *D.18511;
        D.18513 = (int) D.18512;
        __result = D.18510 - D.18513;
        <D.18507>:
        <D.18497>:
        <D.18487>:
      }
      D.17128 = __result;
    }
    iftmp.8 = -D.17128;
    goto <D.18514>;
    <D.18477>:
    iftmp.8 = __builtin_strcmp (p, "/bin");
    <D.18514>:
    D.17129 = iftmp.8;
  }
  if (D.17129 != 0) goto <D.18515>; else goto <D.18516>;
  <D.18515>:
  D.18220 = 0B;
  return D.18220;
  <D.18516>:
  *p = 0;
  D.18220 = path;
  return D.18220;
}


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

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


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


mono_assemblies_init ()
{
  const char * D.18520;

  D.18520 = mono_assembly_getrootdir ();
  if (D.18520 == 0B) goto <D.18521>; else goto <D.18522>;
  <D.18521>:
  mono_set_rootdir ();
  <D.18522>:
  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.18523>; else goto <D.18525>;
  <D.18525>:
  assemblies_path.9 = assemblies_path;
  if (assemblies_path.9 != 0B) goto <D.18523>; else goto <D.18524>;
  <D.18523>:
  return;
  <D.18524>:
  mono_set_assemblies_path (path);
}


check_extra_gac_path_env ()
{
  char * * extra_gac_paths.10;
  char * D.18533;
  char D.18534;
  char * * dest.11;
  const gchar * D.18538;
  int D.18543;
  const char * path;
  char * * splitted;
  char * * dest;

  path = monoeg_g_getenv ("MONO_GAC_PREFIX");
  if (path == 0B) goto <D.18528>; else goto <D.18529>;
  <D.18528>:
  return;
  <D.18529>:
  splitted = monoeg_g_strsplit (path, ":", 1000);
  extra_gac_paths.10 = extra_gac_paths;
  if (extra_gac_paths.10 != 0B) goto <D.18531>; else goto <D.18532>;
  <D.18531>:
  extra_gac_paths.10 = extra_gac_paths;
  monoeg_g_strfreev (extra_gac_paths.10);
  <D.18532>:
  dest = splitted;
  extra_gac_paths = dest;
  goto <D.16971>;
  <D.16970>:
  D.18533 = *splitted;
  D.18534 = *D.18533;
  if (D.18534 != 0) goto <D.18535>; else goto <D.18536>;
  <D.18535>:
  dest.11 = dest;
  dest = dest.11 + 4;
  D.18533 = *splitted;
  *dest.11 = D.18533;
  <D.18536>:
  splitted = splitted + 4;
  <D.16971>:
  D.18533 = *splitted;
  if (D.18533 != 0B) goto <D.16970>; else goto <D.16972>;
  <D.16972>:
  D.18533 = *splitted;
  *dest = D.18533;
  D.18538 = monoeg_g_getenv ("MONO_DEBUG");
  if (D.18538 == 0B) goto <D.18539>; else goto <D.18540>;
  <D.18539>:
  return;
  <D.18540>:
  goto <D.16974>;
  <D.16973>:
  D.18533 = *splitted;
  D.18534 = *D.18533;
  if (D.18534 != 0) goto <D.18541>; else goto <D.18542>;
  <D.18541>:
  D.18533 = *splitted;
  D.18543 = monoeg_g_file_test (D.18533, 4);
  if (D.18543 == 0) goto <D.18544>; else goto <D.18545>;
  <D.18544>:
  D.18533 = *splitted;
  monoeg_g_log (0B, 16, "\'%s\' in MONO_GAC_PREFIX doesn\'t exist or has wrong permissions.", D.18533);
  <D.18545>:
  <D.18542>:
  splitted = splitted + 4;
  <D.16974>:
  D.18533 = *splitted;
  if (D.18533 != 0B) goto <D.16973>; else goto <D.16975>;
  <D.16975>:
}


mono_assembly_fill_assembly_name (struct MonoImage * image, struct MonoAssemblyName * aname)
{
  unsigned int D.18547;
  unsigned int D.18548;
  mono_bool D.18551;
  unsigned int D.18552;
  const char * D.18553;
  unsigned int D.18554;
  const char * D.18555;
  unsigned int D.18556;
  unsigned int D.18557;
  short unsigned int D.18558;
  unsigned int D.18559;
  short unsigned int D.18560;
  unsigned int D.18561;
  short unsigned int D.18562;
  unsigned int D.18563;
  short unsigned int D.18564;
  unsigned int D.18565;
  unsigned int D.18566;
  const char * pkey.12;
  const gchar * pkey.13;
  unsigned int D.18571;
  unsigned int len.14;
  const mono_byte * D.18573;
  mono_byte[17] * D.18574;
  const char * D.18578;
  void * D.18580;
  short unsigned int D.18581;
  unsigned int D.18582;
  int D.18583;
  int D.18587;
  struct MonoTableInfo * t;
  guint32 cols[9];
  gint32 machine;
  gint32 flags;

  try
    {
      t = &image->tables[32];
      D.18547 = BIT_FIELD_REF <*t, 32, 32>;
      D.18548 = D.18547 & 16777215;
      if (D.18548 == 0) goto <D.18549>; else goto <D.18550>;
      <D.18549>:
      D.18551 = 0;
      return D.18551;
      <D.18550>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      aname->hash_len = 0;
      aname->hash_value = 0B;
      D.18552 = cols[7];
      D.18553 = mono_metadata_string_heap (image, D.18552);
      aname->name = D.18553;
      D.18554 = cols[8];
      D.18555 = mono_metadata_string_heap (image, D.18554);
      aname->culture = D.18555;
      D.18556 = cols[5];
      aname->flags = D.18556;
      D.18557 = cols[1];
      D.18558 = (short unsigned int) D.18557;
      aname->major = D.18558;
      D.18559 = cols[2];
      D.18560 = (short unsigned int) D.18559;
      aname->minor = D.18560;
      D.18561 = cols[3];
      D.18562 = (short unsigned int) D.18561;
      aname->build = D.18562;
      D.18563 = cols[4];
      D.18564 = (short unsigned int) D.18563;
      aname->revision = D.18564;
      D.18565 = cols[0];
      aname->hash_alg = D.18565;
      D.18566 = cols[6];
      if (D.18566 != 0) goto <D.18567>; else goto <D.18568>;
      <D.18567>:
      {
        guchar * token;
        gchar * encoded;
        const gchar * pkey;
        int len;

        try
          {
            token = monoeg_malloc (8);
            D.18566 = cols[6];
            pkey.12 = mono_metadata_blob_heap (image, D.18566);
            pkey = pkey.12;
            pkey.13 = pkey;
            D.18571 = mono_metadata_decode_blob_size (pkey.13, &pkey);
            len = (int) D.18571;
            pkey.13 = pkey;
            aname->public_key = pkey.13;
            len.14 = (unsigned int) len;
            D.18573 = aname->public_key;
            mono_digest_get_public_token (token, D.18573, len.14);
            encoded = encode_public_tok (token, 8);
            D.18574 = &aname->public_key_token;
            monoeg_g_strlcpy (D.18574, encoded, 17);
            monoeg_g_free (encoded);
            monoeg_g_free (token);
          }
        finally
          {
            pkey = {CLOBBER};
          }
      }
      goto <D.18575>;
      <D.18568>:
      aname->public_key = 0B;
      D.18574 = &aname->public_key_token;
      memset (D.18574, 0, 17);
      <D.18575>:
      D.18566 = cols[6];
      if (D.18566 != 0) goto <D.18576>; else goto <D.18577>;
      <D.18576>:
      D.18566 = cols[6];
      D.18578 = mono_metadata_blob_heap (image, D.18566);
      aname->public_key = D.18578;
      goto <D.18579>;
      <D.18577>:
      aname->public_key = 0B;
      <D.18579>:
      D.18580 = image->image_info;
      D.18581 = MEM[(struct MonoCLIImageInfo *)D.18580].cli_header.coff.coff_machine;
      machine = (gint32) D.18581;
      D.18580 = image->image_info;
      D.18582 = MEM[(struct MonoCLIImageInfo *)D.18580].cli_cli_header.ch_flags;
      flags = (gint32) D.18582;
      switch (machine) <default: <D.17182>, case 332: <D.17177>, case 452: <D.17181>, case 512: <D.17179>, case 34404: <D.17180>>
      <D.17177>:
      D.18583 = flags & 18;
      if (D.18583 != 0) goto <D.18584>; else goto <D.18585>;
      <D.18584>:
      aname->arch = 2;
      goto <D.18586>;
      <D.18585>:
      D.18587 = flags & 112;
      if (D.18587 == 112) goto <D.18588>; else goto <D.18589>;
      <D.18588>:
      aname->arch = 0;
      goto <D.18590>;
      <D.18589>:
      aname->arch = 1;
      <D.18590>:
      <D.18586>:
      goto <D.17178>;
      <D.17179>:
      aname->arch = 3;
      goto <D.17178>;
      <D.17180>:
      aname->arch = 4;
      goto <D.17178>;
      <D.17181>:
      aname->arch = 5;
      goto <D.17178>;
      <D.17182>:
      goto <D.17178>;
      <D.17178>:
      D.18551 = 1;
      return D.18551;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


encode_public_tok (const guchar * token, gint32 len)
{
  int D.18594;
  int D.18595;
  unsigned int D.18596;
  int D.18597;
  sizetype D.18598;
  gchar * D.18599;
  sizetype i.15;
  const guchar * D.18601;
  unsigned char D.18602;
  unsigned char D.18603;
  int D.18604;
  char D.18605;
  sizetype D.18606;
  gchar * D.18607;
  int D.18608;
  int D.18609;
  char D.18610;
  sizetype D.18611;
  gchar * D.18612;
  gchar * D.18613;
  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.18594 = len * 2;
  D.18595 = D.18594 + 1;
  D.18596 = (unsigned int) D.18595;
  res = monoeg_malloc (D.18596);
  i = 0;
  goto <D.16943>;
  <D.16942>:
  D.18597 = i * 2;
  D.18598 = (sizetype) D.18597;
  D.18599 = res + D.18598;
  i.15 = (sizetype) i;
  D.18601 = token + i.15;
  D.18602 = *D.18601;
  D.18603 = D.18602 >> 4;
  D.18604 = (int) D.18603;
  D.18605 = allowed[D.18604];
  *D.18599 = D.18605;
  D.18597 = i * 2;
  D.18598 = (sizetype) D.18597;
  D.18606 = D.18598 + 1;
  D.18607 = res + D.18606;
  i.15 = (sizetype) i;
  D.18601 = token + i.15;
  D.18602 = *D.18601;
  D.18608 = (int) D.18602;
  D.18609 = D.18608 & 15;
  D.18610 = allowed[D.18609];
  *D.18607 = D.18610;
  i = i + 1;
  <D.16943>:
  if (i < len) goto <D.16942>; else goto <D.16944>;
  <D.16944>:
  D.18594 = len * 2;
  D.18611 = (sizetype) D.18594;
  D.18612 = res + D.18611;
  *D.18612 = 0;
  D.18613 = res;
  return D.18613;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.18617;
  int D.18622;
  void * D.18624;
  unsigned int D.18625;

  D.18617 = __builtin_constant_p (__len);
  if (D.18617 != 0) goto <D.18618>; else goto <D.18619>;
  <D.18618>:
  if (__len == 0) goto <D.18620>; else goto <D.18621>;
  <D.18620>:
  D.18622 = __builtin_constant_p (__ch);
  if (D.18622 == 0) goto <D.18615>; else goto <D.18623>;
  <D.18623>:
  if (__ch != 0) goto <D.18615>; else goto <D.18616>;
  <D.18615>:
  __warn_memset_zero_len ();
  D.18624 = __dest;
  return D.18624;
  <D.18616>:
  <D.18621>:
  <D.18619>:
  D.18625 = __builtin_object_size (__dest, 0);
  D.18624 = __builtin___memset_chk (__dest, __ch, __len, D.18625);
  return D.18624;
}


mono_stringify_assembly_name (struct MonoAssemblyName * aname)
{
  const char * iftmp.16;
  const char * D.18630;
  const short unsigned int * * D.18632;
  const short unsigned int * D.18633;
  char D.18634;
  unsigned int D.18635;
  unsigned int D.18636;
  const short unsigned int * D.18637;
  short unsigned int D.18638;
  int D.18639;
  int D.18640;
  char * D.18642;
  const char * iftmp.17;
  unsigned int D.18644;
  unsigned int D.18645;
  const char * iftmp.18;
  unsigned char D.18650;
  const char * iftmp.19;
  const char * D.18657;
  char D.18659;
  short unsigned int D.18661;
  int D.18662;
  short unsigned int D.18663;
  int D.18664;
  short unsigned int D.18665;
  int D.18666;
  short unsigned int D.18667;
  int D.18668;
  const char * quote;

  D.18630 = aname->name;
  if (D.18630 != 0B) goto <D.18631>; else goto <D.18628>;
  <D.18631>:
  D.18632 = __ctype_b_loc ();
  D.18633 = *D.18632;
  D.18630 = aname->name;
  D.18634 = *D.18630;
  D.18635 = (unsigned int) D.18634;
  D.18636 = D.18635 * 2;
  D.18637 = D.18633 + D.18636;
  D.18638 = *D.18637;
  D.18639 = (int) D.18638;
  D.18640 = D.18639 & 8192;
  if (D.18640 != 0) goto <D.18641>; else goto <D.18628>;
  <D.18641>:
  iftmp.16 = "\"";
  goto <D.18629>;
  <D.18628>:
  iftmp.16 = "";
  <D.18629>:
  quote = iftmp.16;
  D.18644 = aname->flags;
  D.18645 = D.18644 & 256;
  if (D.18645 != 0) goto <D.18646>; else goto <D.18647>;
  <D.18646>:
  iftmp.17 = ", Retargetable=Yes";
  goto <D.18648>;
  <D.18647>:
  iftmp.17 = "";
  <D.18648>:
  D.18650 = aname->public_key_token[0];
  if (D.18650 != 0) goto <D.18651>; else goto <D.18652>;
  <D.18651>:
  iftmp.18 = &aname->public_key_token;
  goto <D.18653>;
  <D.18652>:
  iftmp.18 = "null";
  <D.18653>:
  D.18657 = aname->culture;
  if (D.18657 != 0B) goto <D.18658>; else goto <D.18655>;
  <D.18658>:
  D.18657 = aname->culture;
  D.18659 = *D.18657;
  if (D.18659 != 0) goto <D.18660>; else goto <D.18655>;
  <D.18660>:
  iftmp.19 = aname->culture;
  goto <D.18656>;
  <D.18655>:
  iftmp.19 = "neutral";
  <D.18656>:
  D.18661 = aname->revision;
  D.18662 = (int) D.18661;
  D.18663 = aname->build;
  D.18664 = (int) D.18663;
  D.18665 = aname->minor;
  D.18666 = (int) D.18665;
  D.18667 = aname->major;
  D.18668 = (int) D.18667;
  D.18630 = aname->name;
  D.18642 = monoeg_g_strdup_printf ("%s%s%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", quote, D.18630, quote, D.18668, D.18666, D.18664, D.18662, iftmp.19, iftmp.18, iftmp.17);
  return D.18642;
}


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

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.18671;
  unsigned int D.18672;

  D.18672 = __sync_add_and_fetch_4 (val, 1);
  D.18671 = (gint32) D.18672;
  return D.18671;
}


mono_assembly_get_assemblyref (struct MonoImage * image, int index, struct MonoAssemblyName * aname)
{
  unsigned int D.18674;
  const char * hash.20;
  const char * hash.21;
  unsigned int D.18677;
  unsigned int D.18678;
  const char * D.18679;
  unsigned int D.18680;
  const char * D.18681;
  unsigned int D.18682;
  unsigned int D.18683;
  short unsigned int D.18684;
  unsigned int D.18685;
  short unsigned int D.18686;
  unsigned int D.18687;
  short unsigned int D.18688;
  unsigned int D.18689;
  short unsigned int D.18690;
  unsigned int D.18691;
  unsigned int D.18694;
  mono_byte[17] * D.18695;
  struct MonoTableInfo * t;
  guint32 cols[9];
  const char * hash;

  try
    {
      t = &image->tables[35];
      mono_metadata_decode_row (t, index, &cols, 9);
      D.18674 = cols[8];
      hash.20 = mono_metadata_blob_heap (image, D.18674);
      hash = hash.20;
      hash.21 = hash;
      D.18677 = mono_metadata_decode_blob_size (hash.21, &hash);
      aname->hash_len = D.18677;
      hash.21 = hash;
      aname->hash_value = hash.21;
      D.18678 = cols[6];
      D.18679 = mono_metadata_string_heap (image, D.18678);
      aname->name = D.18679;
      D.18680 = cols[7];
      D.18681 = mono_metadata_string_heap (image, D.18680);
      aname->culture = D.18681;
      D.18682 = cols[4];
      aname->flags = D.18682;
      D.18683 = cols[0];
      D.18684 = (short unsigned int) D.18683;
      aname->major = D.18684;
      D.18685 = cols[1];
      D.18686 = (short unsigned int) D.18685;
      aname->minor = D.18686;
      D.18687 = cols[2];
      D.18688 = (short unsigned int) D.18687;
      aname->build = D.18688;
      D.18689 = cols[3];
      D.18690 = (short unsigned int) D.18689;
      aname->revision = D.18690;
      D.18691 = cols[5];
      if (D.18691 != 0) goto <D.18692>; else goto <D.18693>;
      <D.18692>:
      {
        gchar * token;

        D.18694 = aname->flags;
        D.18691 = cols[5];
        token = assemblyref_public_tok (image, D.18691, D.18694);
        D.18695 = &aname->public_key_token;
        monoeg_g_strlcpy (D.18695, token, 17);
        monoeg_g_free (token);
      }
      goto <D.18696>;
      <D.18693>:
      D.18695 = &aname->public_key_token;
      memset (D.18695, 0, 17);
      <D.18696>:
    }
  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.18699;
  unsigned int D.18700;
  unsigned int len.24;
  gchar * D.18704;
  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.18699 = mono_metadata_decode_blob_size (public_tok.23, &public_tok);
      len = (int) D.18699;
      D.18700 = flags & 1;
      if (D.18700 != 0) goto <D.18701>; else goto <D.18702>;
      <D.18701>:
      {
        guchar token[8];

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


mono_assembly_load_reference (struct MonoImage * image, int index)
{
  _Bool D.18710;
  long int D.18711;
  long int D.18712;
  struct MonoAssembly * * D.18715;
  <unnamed-unsigned:24> D.18718;
  int D.18719;
  int D.18720;
  unsigned int D.18721;
  unsigned int D.18722;
  void * D.18723;
  unsigned int index.25;
  unsigned int D.18725;
  struct MonoAssembly * * D.18726;
  _Bool D.18729;
  long int D.18730;
  long int D.18731;
  struct MonoAssembly * D.18738;
  int D.18740;
  int D.17282;
  int iftmp.26;
  int D.17281;
  const char[9] * D.18745;
  unsigned char D.18746;
  int D.18747;
  unsigned char D.18748;
  int D.18749;
  _Bool D.18750;
  _Bool D.18751;
  _Bool D.18752;
  const unsigned char * D.18755;
  unsigned char D.18756;
  int D.18757;
  const unsigned char * D.18758;
  unsigned char D.18759;
  int D.18760;
  _Bool D.18761;
  _Bool D.18762;
  const unsigned char * D.18765;
  unsigned char D.18766;
  int D.18767;
  const unsigned char * D.18768;
  unsigned char D.18769;
  int D.18770;
  _Bool D.18771;
  _Bool D.18772;
  const unsigned char * D.18775;
  unsigned char D.18776;
  int D.18777;
  const unsigned char * D.18778;
  unsigned char D.18779;
  int D.18780;
  const char * D.18782;
  char * D.18785;
  const char * iftmp.27;
  <unnamed type> status.28;
  int * D.18801;
  int D.18802;
  const char * iftmp.29;
  char * D.18810;
  const char * iftmp.30;
  mono_byte[17] * D.18819;
  char D.18820;
  short unsigned int D.18824;
  int D.18825;
  short unsigned int D.18826;
  int D.18827;
  short unsigned int D.18828;
  int D.18829;
  short unsigned int D.18830;
  int D.18831;
  char * D.18832;
  _Bool D.18835;
  long int D.18836;
  long int D.18837;
  struct MonoAssembly * D.18842;
  int D.18849;
  const char * D.18850;
  const char * D.18851;
  _Bool D.18857;
  long int D.18858;
  long int D.18859;
  struct MonoAssembly * reference;
  struct MonoAssemblyName aname;
  MonoImageOpenStatus status;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18708>; else goto <D.18709>;
        <D.18708>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.18709>:
        D.18710 = ret != 0;
        D.18711 = (long int) D.18710;
        D.18712 = __builtin_expect (D.18711, 0);
        if (D.18712 != 0) goto <D.18713>; else goto <D.18714>;
        <D.18713>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1074, "ret == 0");
        <D.18714>:
      }
      D.18715 = image->references;
      if (D.18715 == 0B) goto <D.18716>; else goto <D.18717>;
      <D.18716>:
      {
        struct MonoTableInfo * t;

        t = &image->tables[35];
        D.18718 = t->rows;
        D.18719 = (int) D.18718;
        D.18720 = D.18719 + 1;
        D.18721 = (unsigned int) D.18720;
        D.18722 = D.18721 * 4;
        D.18723 = monoeg_malloc0 (D.18722);
        image->references = D.18723;
        D.18718 = t->rows;
        D.18719 = (int) D.18718;
        image->nreferences = D.18719;
      }
      <D.18717>:
      D.18715 = image->references;
      index.25 = (unsigned int) index;
      D.18725 = index.25 * 4;
      D.18726 = D.18715 + D.18725;
      reference = *D.18726;
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18727>; else goto <D.18728>;
        <D.18727>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.18728>:
        D.18729 = ret != 0;
        D.18730 = (long int) D.18729;
        D.18731 = __builtin_expect (D.18730, 0);
        if (D.18731 != 0) goto <D.18732>; else goto <D.18733>;
        <D.18732>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1082, "ret == 0");
        <D.18733>:
      }
      if (reference != 0B) goto <D.18734>; else goto <D.18735>;
      <D.18734>:
      return;
      <D.18735>:
      mono_assembly_get_assemblyref (image, index, &aname);
      D.18738 = image->assembly;
      if (D.18738 != 0B) goto <D.18739>; else goto <D.18736>;
      <D.18739>:
      D.18738 = image->assembly;
      D.18740 = D.18738->ref_only;
      if (D.18740 != 0) goto <D.18741>; else goto <D.18736>;
      <D.18741>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = aname.name;
          D.18745 = "mscorlib";
          D.18746 = MEM[(const unsigned char *)D.18745];
          D.18747 = (int) D.18746;
          D.18748 = *__s2;
          D.18749 = (int) D.18748;
          __result = D.18747 - D.18749;
          {
            D.18750 = __s2_len != 0;
            D.18751 = __result == 0;
            D.18752 = D.18750 & D.18751;
            if (D.18752 != 0) goto <D.18753>; else goto <D.18754>;
            <D.18753>:
            D.18755 = &MEM[(void *)"mscorlib" + 1B];
            D.18756 = *D.18755;
            D.18757 = (int) D.18756;
            D.18758 = __s2 + 1;
            D.18759 = *D.18758;
            D.18760 = (int) D.18759;
            __result = D.18757 - D.18760;
            D.18761 = __s2_len > 1;
            D.18751 = __result == 0;
            D.18762 = D.18761 & D.18751;
            if (D.18762 != 0) goto <D.18763>; else goto <D.18764>;
            <D.18763>:
            D.18765 = &MEM[(void *)"mscorlib" + 2B];
            D.18766 = *D.18765;
            D.18767 = (int) D.18766;
            D.18768 = __s2 + 2;
            D.18769 = *D.18768;
            D.18770 = (int) D.18769;
            __result = D.18767 - D.18770;
            D.18771 = __s2_len > 2;
            D.18751 = __result == 0;
            D.18772 = D.18771 & D.18751;
            if (D.18772 != 0) goto <D.18773>; else goto <D.18774>;
            <D.18773>:
            D.18775 = &MEM[(void *)"mscorlib" + 3B];
            D.18776 = *D.18775;
            D.18777 = (int) D.18776;
            D.18778 = __s2 + 3;
            D.18779 = *D.18778;
            D.18780 = (int) D.18779;
            __result = D.18777 - D.18780;
            <D.18774>:
            <D.18764>:
            <D.18754>:
          }
          D.17281 = __result;
        }
        iftmp.26 = -D.17281;
        goto <D.18781>;
        <D.18744>:
        D.18782 = aname.name;
        iftmp.26 = __builtin_strcmp (D.18782, "mscorlib");
        <D.18781>:
        D.17282 = iftmp.26;
      }
      if (D.17282 == 0) goto <D.18783>; else goto <D.18784>;
      <D.18783>:
      D.18738 = image->assembly;
      D.18785 = D.18738->basedir;
      reference = mono_assembly_load_full (&aname, D.18785, &status, 0);
      goto <D.18786>;
      <D.18784>:
      reference = mono_assembly_loaded_full (&aname, 1);
      if (reference == 0B) goto <D.18787>; else goto <D.18788>;
      <D.18787>:
      reference = mono_assembly_invoke_search_hook_internal (&aname, 1, 1);
      <D.18788>:
      <D.18786>:
      if (reference == 0B) goto <D.18789>; else goto <D.18790>;
      <D.18789>:
      reference = 4294967295B;
      <D.18790>:
      goto <D.18737>;
      <D.18736>:
      D.18738 = image->assembly;
      if (D.18738 != 0B) goto <D.18792>; else goto <D.18793>;
      <D.18792>:
      D.18738 = image->assembly;
      iftmp.27 = D.18738->basedir;
      goto <D.18794>;
      <D.18793>:
      iftmp.27 = 0B;
      <D.18794>:
      reference = mono_assembly_load (&aname, iftmp.27, &status);
      <D.18737>:
      if (reference == 0B) goto <D.18795>; else goto <D.18796>;
      <D.18795>:
      {
        char * extra_msg;

        status.28 = status;
        if (status.28 == 1) goto <D.18800>; else goto <D.18797>;
        <D.18800>:
        D.18801 = __errno_location ();
        D.18802 = *D.18801;
        if (D.18802 == 2) goto <D.18803>; else goto <D.18797>;
        <D.18803>:
        D.18738 = image->assembly;
        if (D.18738 != 0B) goto <D.18805>; else goto <D.18806>;
        <D.18805>:
        D.18738 = image->assembly;
        iftmp.29 = D.18738->basedir;
        goto <D.18807>;
        <D.18806>:
        iftmp.29 = "";
        <D.18807>:
        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.18798>;
        <D.18797>:
        status.28 = status;
        if (status.28 == 1) goto <D.18808>; else goto <D.18809>;
        <D.18808>:
        D.18801 = __errno_location ();
        D.18802 = *D.18801;
        D.18810 = strerror (D.18802);
        extra_msg = monoeg_g_strdup_printf ("System error: %s\n", D.18810);
        goto <D.18811>;
        <D.18809>:
        status.28 = status;
        if (status.28 == 2) goto <D.18812>; else goto <D.18813>;
        <D.18812>:
        extra_msg = monoeg_strdup ("Cannot find an assembly referenced from this one.\n");
        goto <D.18814>;
        <D.18813>:
        status.28 = status;
        if (status.28 == 3) goto <D.18815>; else goto <D.18816>;
        <D.18815>:
        extra_msg = monoeg_strdup ("The file exists but is not a valid assembly.\n");
        goto <D.18817>;
        <D.18816>:
        extra_msg = monoeg_strdup ("");
        <D.18817>:
        <D.18814>:
        <D.18811>:
        <D.18798>:
        D.18819 = &aname.public_key_token;
        D.18820 = MEM[(const char *)D.18819];
        if (D.18820 != 0) goto <D.18821>; else goto <D.18822>;
        <D.18821>:
        iftmp.30 = &aname.public_key_token;
        goto <D.18823>;
        <D.18822>:
        iftmp.30 = "(none)";
        <D.18823>:
        D.18824 = aname.revision;
        D.18825 = (int) D.18824;
        D.18826 = aname.build;
        D.18827 = (int) D.18826;
        D.18828 = aname.minor;
        D.18829 = (int) D.18828;
        D.18830 = aname.major;
        D.18831 = (int) D.18830;
        D.18782 = aname.name;
        D.18832 = image->name;
        mono_trace (16, 1, "The following assembly referenced from %s could not be loaded:\n     Assembly:   %s    (assemblyref_index=%d)\n     Version:    %d.%d.%d.%d\n     Public Key: %s\n%s", D.18832, D.18782, index, D.18831, D.18829, D.18827, D.18825, iftmp.30, extra_msg);
        monoeg_g_free (extra_msg);
      }
      <D.18796>:
      {
        int ret;

        ret = pthread_mutex_lock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18833>; else goto <D.18834>;
        <D.18833>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.18834>:
        D.18835 = ret != 0;
        D.18836 = (long int) D.18835;
        D.18837 = __builtin_expect (D.18836, 0);
        if (D.18837 != 0) goto <D.18838>; else goto <D.18839>;
        <D.18838>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1133, "ret == 0");
        <D.18839>:
      }
      if (reference == 0B) goto <D.18840>; else goto <D.18841>;
      <D.18840>:
      reference = 4294967295B;
      <D.18841>:
      D.18715 = image->references;
      index.25 = (unsigned int) index;
      D.18725 = index.25 * 4;
      D.18726 = D.18715 + D.18725;
      D.18842 = *D.18726;
      if (D.18842 == 0B) goto <D.18843>; else goto <D.18844>;
      <D.18843>:
      if (reference != 4294967295B) goto <D.18845>; else goto <D.18846>;
      <D.18845>:
      mono_assembly_addref (reference);
      D.18738 = image->assembly;
      if (D.18738 != 0B) goto <D.18847>; else goto <D.18848>;
      <D.18847>:
      D.18849 = reference->ref_count;
      D.18850 = reference->aname.name;
      D.18738 = image->assembly;
      D.18738 = image->assembly;
      D.18851 = D.18738->aname.name;
      mono_trace (64, 1, "Assembly Ref addref %s[%p] -> %s[%p]: %d", D.18851, D.18738, D.18850, reference, D.18849);
      <D.18848>:
      goto <D.18852>;
      <D.18846>:
      D.18738 = image->assembly;
      if (D.18738 != 0B) goto <D.18853>; else goto <D.18854>;
      <D.18853>:
      D.18738 = image->assembly;
      D.18738 = image->assembly;
      D.18851 = D.18738->aname.name;
      mono_trace (64, 1, "Failed to load assembly %s[%p]\n", D.18851, D.18738);
      <D.18854>:
      <D.18852>:
      D.18715 = image->references;
      index.25 = (unsigned int) index;
      D.18725 = index.25 * 4;
      D.18726 = D.18715 + D.18725;
      *D.18726 = reference;
      <D.18844>:
      {
        int ret;

        ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
        if (ret != 0) goto <D.18855>; else goto <D.18856>;
        <D.18855>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.18856>:
        D.18857 = ret != 0;
        D.18858 = (long int) D.18857;
        D.18859 = __builtin_expect (D.18858, 0);
        if (D.18859 != 0) goto <D.18860>; else goto <D.18861>;
        <D.18860>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1153, "ret == 0");
        <D.18861>:
      }
      D.18715 = image->references;
      index.25 = (unsigned int) index;
      D.18725 = index.25 * 4;
      D.18726 = D.18715 + D.18725;
      D.18842 = *D.18726;
      if (D.18842 != reference) goto <D.18862>; else goto <D.18863>;
      <D.18862>:
      mono_assembly_close (reference);
      <D.18863>:
    }
  finally
    {
      aname = {CLOBBER};
      status = {CLOBBER};
    }
}


mono_assembly_invoke_search_hook_internal (struct MonoAssemblyName * aname, gboolean refonly, gboolean postload)
{
  int D.18867;
  int D.18870;
  struct MonoAssembly * (*<Te7a>) (struct MonoAssemblyName *, void *) D.18873;
  void * D.18874;
  struct MonoAssembly * D.18877;
  struct AssemblySearchHook * hook;

  hook = assembly_search_hook;
  goto <D.17332>;
  <D.17331>:
  D.18867 = hook->refonly;
  if (D.18867 == refonly) goto <D.18868>; else goto <D.18869>;
  <D.18868>:
  D.18870 = hook->postload;
  if (D.18870 == postload) goto <D.18871>; else goto <D.18872>;
  <D.18871>:
  {
    struct MonoAssembly * ass;

    D.18873 = hook->func;
    D.18874 = hook->user_data;
    ass = D.18873 (aname, D.18874);
    if (ass != 0B) goto <D.18875>; else goto <D.18876>;
    <D.18875>:
    D.18877 = ass;
    return D.18877;
    <D.18876>:
  }
  <D.18872>:
  <D.18869>:
  hook = hook->next;
  <D.17332>:
  if (hook != 0B) goto <D.17331>; else goto <D.17333>;
  <D.17333>:
  D.18877 = 0B;
  return D.18877;
}


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


mono_assembly_invoke_load_hook (struct MonoAssembly * ass)
{
  void (*<Te73>) (struct MonoAssembly *, void *) D.18879;
  void * D.18880;
  struct AssemblyLoadHook * hook;

  hook = assembly_load_hook;
  goto <D.17301>;
  <D.17300>:
  D.18879 = hook->func;
  D.18880 = hook->user_data;
  D.18879 (ass, D.18880);
  hook = hook->next;
  <D.17301>:
  if (hook != 0B) goto <D.17300>; else goto <D.17302>;
  <D.17302>:
}


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.18881>; else goto <D.18882>;
  <D.18881>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1192, "func != NULL");
  return;
  <D.18882>:
  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.18885;

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


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.18887>; else goto <D.18888>;
  <D.18887>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1250, "func != NULL");
  return;
  <D.18888>:
  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.18891>; else goto <D.18892>;
  <D.18891>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1341, "func != NULL");
  return;
  <D.18892>:
  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.18895>; else goto <D.18896>;
  <D.18895>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1355, "func != NULL");
  return;
  <D.18896>:
  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.18902;
  _Bool D.18905;
  long int D.18906;
  long int D.18907;
  int D.17468;
  unsigned int i.36;
  unsigned int D.18911;
  const struct MonoBundledAssembly * * D.18912;
  const struct MonoBundledAssembly * D.18913;
  const char * D.18914;
  unsigned int D.18917;
  const unsigned char * D.18918;
  _Bool D.18922;
  long int D.18923;
  long int D.18924;
  int i;
  char * name;
  struct MonoImage * image;

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

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18903>; else goto <D.18904>;
    <D.18903>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18904>:
    D.18905 = ret != 0;
    D.18906 = (long int) D.18905;
    D.18907 = __builtin_expect (D.18906, 0);
    if (D.18907 != 0) goto <D.18908>; else goto <D.18909>;
    <D.18908>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1466, "ret == 0");
    <D.18909>:
  }
  i = 0;
  goto <D.17471>;
  <D.17470>:
  {
    size_t __s1_len;
    size_t __s2_len;

    bundles.35 = bundles;
    i.36 = (unsigned int) i;
    D.18911 = i.36 * 4;
    D.18912 = bundles.35 + D.18911;
    D.18913 = *D.18912;
    D.18914 = D.18913->name;
    D.17468 = __builtin_strcmp (D.18914, name);
  }
  if (D.17468 == 0) goto <D.18915>; else goto <D.18916>;
  <D.18915>:
  bundles.35 = bundles;
  i.36 = (unsigned int) i;
  D.18911 = i.36 * 4;
  D.18912 = bundles.35 + D.18911;
  D.18913 = *D.18912;
  D.18917 = D.18913->size;
  bundles.35 = bundles;
  i.36 = (unsigned int) i;
  D.18911 = i.36 * 4;
  D.18912 = bundles.35 + D.18911;
  D.18913 = *D.18912;
  D.18918 = D.18913->data;
  image = mono_image_open_from_data_with_name (D.18918, D.18917, 0, status, refonly, name);
  goto <D.17469>;
  <D.18916>:
  i = i + 1;
  <D.17471>:
  if (image == 0B) goto <D.18919>; else goto <D.17469>;
  <D.18919>:
  bundles.35 = bundles;
  i.36 = (unsigned int) i;
  D.18911 = i.36 * 4;
  D.18912 = bundles.35 + D.18911;
  D.18913 = *D.18912;
  if (D.18913 != 0B) goto <D.17470>; else goto <D.17469>;
  <D.17469>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.18920>; else goto <D.18921>;
    <D.18920>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18921>:
    D.18922 = ret != 0;
    D.18923 = (long int) D.18922;
    D.18924 = __builtin_expect (D.18923, 0);
    if (D.18924 != 0) goto <D.18925>; else goto <D.18926>;
    <D.18925>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1473, "ret == 0");
    <D.18926>:
  }
  monoeg_g_free (name);
  if (image != 0B) goto <D.18927>; else goto <D.18928>;
  <D.18927>:
  mono_image_addref (image);
  D.18902 = image;
  return D.18902;
  <D.18928>:
  D.18902 = 0B;
  return D.18902;
}


mono_assembly_open_full (const char * filename, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.18932;
  int D.18935;
  gchar * D.18938;
  char D.18939;
  struct GError * error.37;
  gchar * D.18947;
  unsigned char D.18949;
  _Bool D.18952;
  _Bool D.18953;
  _Bool D.18954;
  const struct MonoBundledAssembly * * bundles.38;
  <unnamed type> D.18964;
  struct MonoAssembly * D.18967;
  struct MonoImage * D.18974;
  struct MonoImage * image;
  struct MonoAssembly * ass;
  MonoImageOpenStatus def_status;
  gchar * fname;
  gchar * new_fname;

  try
    {
      if (filename == 0B) goto <D.18930>; else goto <D.18931>;
      <D.18930>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 1491, "filename != NULL");
      D.18932 = 0B;
      return D.18932;
      <D.18931>:
      if (status == 0B) goto <D.18933>; else goto <D.18934>;
      <D.18933>:
      status = &def_status;
      <D.18934>:
      *status = 0;
      D.18935 = strncmp (filename, "file://", 7);
      if (D.18935 == 0) goto <D.18936>; else goto <D.18937>;
      <D.18936>:
      {
        struct GError * error;
        gchar * uri;
        gchar * tmpuri;

        try
          {
            error = 0B;
            uri = filename;
            D.18938 = uri + 7;
            D.18939 = *D.18938;
            if (D.18939 != 47) goto <D.18940>; else goto <D.18941>;
            <D.18940>:
            D.18938 = uri + 7;
            uri = monoeg_g_strdup_printf ("file:///%s", D.18938);
            <D.18941>:
            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.18942>; else goto <D.18943>;
            <D.18942>:
            monoeg_g_free (tmpuri);
            <D.18943>:
            error.37 = error;
            if (error.37 != 0B) goto <D.18945>; else goto <D.18946>;
            <D.18945>:
            error.37 = error;
            D.18947 = error.37->message;
            monoeg_g_log (0B, 16, "%s\n", D.18947);
            error.37 = error;
            monoeg_g_error_free (error.37);
            fname = monoeg_strdup (filename);
            <D.18946>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      goto <D.18948>;
      <D.18937>:
      fname = monoeg_strdup (filename);
      <D.18948>:
      mono_trace (64, 1, "Assembly Loader probing location: \'%s\'.", fname);
      new_fname = 0B;
      D.18949 = mono_assembly_is_in_gac (fname);
      if (D.18949 == 0) goto <D.18950>; else goto <D.18951>;
      <D.18950>:
      new_fname = mono_make_shadow_copy (fname);
      <D.18951>:
      D.18952 = new_fname != 0B;
      D.18953 = new_fname != fname;
      D.18954 = D.18952 & D.18953;
      if (D.18954 != 0) goto <D.18955>; else goto <D.18956>;
      <D.18955>:
      monoeg_g_free (fname);
      fname = new_fname;
      mono_trace (64, 1, "Assembly Loader shadow-copied assembly to: \'%s\'.", fname);
      <D.18956>:
      image = 0B;
      bundles.38 = bundles;
      if (bundles.38 != 0B) goto <D.18958>; else goto <D.18959>;
      <D.18958>:
      image = mono_assembly_open_from_bundle (fname, status, refonly);
      <D.18959>:
      if (image == 0B) goto <D.18960>; else goto <D.18961>;
      <D.18960>:
      image = mono_image_open_full (fname, status, refonly);
      <D.18961>:
      if (image == 0B) goto <D.18962>; else goto <D.18963>;
      <D.18962>:
      D.18964 = *status;
      if (D.18964 == 0) goto <D.18965>; else goto <D.18966>;
      <D.18965>:
      *status = 1;
      <D.18966>:
      monoeg_g_free (fname);
      D.18932 = 0B;
      return D.18932;
      <D.18963>:
      D.18967 = image->assembly;
      if (D.18967 != 0B) goto <D.18968>; else goto <D.18969>;
      <D.18968>:
      D.18967 = image->assembly;
      mono_assembly_invoke_load_hook (D.18967);
      mono_image_close (image);
      monoeg_g_free (fname);
      D.18932 = image->assembly;
      return D.18932;
      <D.18969>:
      ass = mono_assembly_load_from_full (image, fname, status, refonly);
      if (ass != 0B) goto <D.18970>; else goto <D.18971>;
      <D.18970>:
      mono_trace (64, 1, "Assembly Loader loaded assembly from location: \'%s\'.", filename);
      if (refonly == 0) goto <D.18972>; else goto <D.18973>;
      <D.18972>:
      D.18974 = ass->image;
      mono_config_for_assembly (D.18974);
      <D.18973>:
      <D.18971>:
      mono_image_close (image);
      monoeg_g_free (fname);
      D.18932 = ass;
      return D.18932;
    }
  finally
    {
      def_status = {CLOBBER};
    }
}


mono_assembly_is_in_gac (const gchar * filename)
{
  MonoBoolean D.18979;
  gchar * D.18980;
  char * D.18981;
  unsigned int D.18984;
  char D.18985;
  int D.18988;
  int D.18993;
  int D.18998;
  char * D.19004;
  unsigned int D.19007;
  int D.19010;
  int D.19015;
  const gchar * rootdir;
  gchar * gp;
  gchar * * paths;

  if (filename == 0B) goto <D.18977>; else goto <D.18978>;
  <D.18977>:
  D.18979 = 0;
  return D.18979;
  <D.18978>:
  paths = extra_gac_paths;
  goto <D.17776>;
  <D.17775>:
  D.18980 = *paths;
  D.18981 = strstr (D.18980, filename);
  D.18980 = *paths;
  if (D.18981 != D.18980) goto <D.18982>; else goto <D.18983>;
  <D.18982>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.18983>:
  D.18980 = *paths;
  D.18984 = strlen (D.18980);
  gp = filename + D.18984;
  D.18985 = *gp;
  if (D.18985 != 47) goto <D.18986>; else goto <D.18987>;
  <D.18986>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.18987>:
  gp = gp + 1;
  D.18988 = strncmp (gp, "lib", 3);
  if (D.18988 != 0) goto <D.18989>; else goto <D.18990>;
  <D.18989>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.18990>:
  gp = gp + 3;
  D.18985 = *gp;
  if (D.18985 != 47) goto <D.18991>; else goto <D.18992>;
  <D.18991>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.18992>:
  gp = gp + 1;
  D.18993 = strncmp (gp, "mono", 4);
  if (D.18993 != 0) goto <D.18994>; else goto <D.18995>;
  <D.18994>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.18995>:
  gp = gp + 4;
  D.18985 = *gp;
  if (D.18985 != 47) goto <D.18996>; else goto <D.18997>;
  <D.18996>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.18997>:
  gp = gp + 1;
  D.18998 = strncmp (gp, "gac", 3);
  if (D.18998 != 0) goto <D.18999>; else goto <D.19000>;
  <D.18999>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.19000>:
  gp = gp + 3;
  D.18985 = *gp;
  if (D.18985 != 47) goto <D.19001>; else goto <D.19002>;
  <D.19001>:
  // predicted unlikely by continue predictor.
  goto <D.17747>;
  <D.19002>:
  D.18979 = 1;
  return D.18979;
  <D.17747>:
  paths = paths + 4;
  <D.17776>:
  if (paths != 0B) goto <D.19003>; else goto <D.17777>;
  <D.19003>:
  D.18980 = *paths;
  if (D.18980 != 0B) goto <D.17775>; else goto <D.17777>;
  <D.17777>:
  rootdir = mono_assembly_getrootdir ();
  D.19004 = strstr (filename, rootdir);
  if (D.19004 != filename) goto <D.19005>; else goto <D.19006>;
  <D.19005>:
  D.18979 = 0;
  return D.18979;
  <D.19006>:
  D.19007 = strlen (rootdir);
  gp = filename + D.19007;
  D.18985 = *gp;
  if (D.18985 != 47) goto <D.19008>; else goto <D.19009>;
  <D.19008>:
  D.18979 = 0;
  return D.18979;
  <D.19009>:
  gp = gp + 1;
  D.19010 = strncmp (gp, "mono", 4);
  if (D.19010 != 0) goto <D.19011>; else goto <D.19012>;
  <D.19011>:
  D.18979 = 0;
  return D.18979;
  <D.19012>:
  gp = gp + 4;
  D.18985 = *gp;
  if (D.18985 != 47) goto <D.19013>; else goto <D.19014>;
  <D.19013>:
  D.18979 = 0;
  return D.18979;
  <D.19014>:
  gp = gp + 1;
  D.19015 = strncmp (gp, "gac", 3);
  if (D.19015 != 0) goto <D.19016>; else goto <D.19017>;
  <D.19016>:
  D.18979 = 0;
  return D.18979;
  <D.19017>:
  gp = gp + 3;
  D.18985 = *gp;
  if (D.18985 != 47) goto <D.19018>; else goto <D.19019>;
  <D.19018>:
  D.18979 = 0;
  return D.18979;
  <D.19019>:
  D.18979 = 1;
  return D.18979;
}


mono_assembly_load_friends (struct MonoAssembly * ass)
{
  unsigned char D.19021;
  _Bool D.19028;
  long int D.19029;
  long int D.19030;
  _Bool D.19035;
  long int D.19036;
  long int D.19037;
  _Bool D.19042;
  long int D.19043;
  long int D.19044;
  _Bool D.19051;
  long int D.19052;
  long int D.19053;
  _Bool D.19058;
  long int D.19059;
  long int D.19060;
  struct MonoMethod * D.19065;
  struct MonoClass * D.19067;
  struct MonoClass * D.19068;
  unsigned int D.19069;
  const mono_byte * data.39;
  const gchar * data.40;
  char D.19076;
  const gchar * D.19078;
  char D.19079;
  const gchar * D.19081;
  char D.19082;
  int D.19083;
  int D.19084;
  const char * D.19085;
  int D.19086;
  int D.19090;
  _Bool D.19093;
  long int D.19094;
  long int D.19095;
  _Bool D.19102;
  long int D.19103;
  long int D.19104;
  _Bool D.19109;
  long int D.19110;
  long int D.19111;
  int i;
  struct MonoCustomAttrInfo * attrs;
  struct GSList * list;

  D.19021 = ass->friend_assembly_names_inited;
  if (D.19021 != 0) goto <D.19022>; else goto <D.19023>;
  <D.19022>:
  return;
  <D.19023>:
  attrs = mono_custom_attrs_from_assembly (ass);
  if (attrs == 0B) goto <D.19024>; else goto <D.19025>;
  <D.19024>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19026>; else goto <D.19027>;
    <D.19026>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19027>:
    D.19028 = ret != 0;
    D.19029 = (long int) D.19028;
    D.19030 = __builtin_expect (D.19029, 0);
    if (D.19030 != 0) goto <D.19031>; else goto <D.19032>;
    <D.19031>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1611, "ret == 0");
    <D.19032>:
  }
  ass->friend_assembly_names_inited = 1;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19033>; else goto <D.19034>;
    <D.19033>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19034>:
    D.19035 = ret != 0;
    D.19036 = (long int) D.19035;
    D.19037 = __builtin_expect (D.19036, 0);
    if (D.19037 != 0) goto <D.19038>; else goto <D.19039>;
    <D.19038>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1613, "ret == 0");
    <D.19039>:
  }
  return;
  <D.19025>:
  {
    int ret;

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

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19049>; else goto <D.19050>;
    <D.19049>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19050>:
    D.19051 = ret != 0;
    D.19052 = (long int) D.19051;
    D.19053 = __builtin_expect (D.19052, 0);
    if (D.19053 != 0) goto <D.19054>; else goto <D.19055>;
    <D.19054>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1619, "ret == 0");
    <D.19055>:
  }
  return;
  <D.19048>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19056>; else goto <D.19057>;
    <D.19056>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19057>:
    D.19058 = ret != 0;
    D.19059 = (long int) D.19058;
    D.19060 = __builtin_expect (D.19059, 0);
    if (D.19060 != 0) goto <D.19061>; else goto <D.19062>;
    <D.19061>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1622, "ret == 0");
    <D.19062>:
  }
  list = 0B;
  i = 0;
  goto <D.17516>;
  <D.17515>:
  {
    struct MonoCustomAttrEntry * attr;
    struct MonoAssemblyName * aname;
    const gchar * data;
    guint slen;

    try
      {
        attr = &attrs->attrs[i];
        D.19065 = attr->ctor;
        if (D.19065 == 0B) goto <D.19063>; else goto <D.19066>;
        <D.19066>:
        D.19065 = attr->ctor;
        D.19067 = D.19065->klass;
        D.19068 = mono_defaults.internals_visible_class;
        if (D.19067 != D.19068) goto <D.19063>; else goto <D.19064>;
        <D.19063>:
        // predicted unlikely by continue predictor.
        goto <D.17514>;
        <D.19064>:
        D.19069 = attr->data_size;
        if (D.19069 <= 3) goto <D.19070>; else goto <D.19071>;
        <D.19070>:
        // predicted unlikely by continue predictor.
        goto <D.17514>;
        <D.19071>:
        data.39 = attr->data;
        data = data.39;
        data.40 = data;
        D.19076 = *data.40;
        if (D.19076 != 1) goto <D.19073>; else goto <D.19077>;
        <D.19077>:
        data.40 = data;
        D.19078 = data.40 + 1;
        D.19079 = *D.19078;
        if (D.19079 != 0) goto <D.19073>; else goto <D.19080>;
        <D.19080>:
        data.40 = data;
        D.19081 = data.40 + 2;
        D.19082 = *D.19081;
        D.19083 = (int) D.19082;
        D.19084 = D.19083 & 255;
        if (D.19084 == 255) goto <D.19073>; else goto <D.19074>;
        <D.19073>:
        // predicted unlikely by continue predictor.
        goto <D.17514>;
        <D.19074>:
        data.40 = data;
        D.19085 = data.40 + 2;
        slen = mono_metadata_decode_value (D.19085, &data);
        aname = monoeg_malloc0 (60);
        data.40 = data;
        D.19086 = mono_assembly_name_parse_full (data.40, aname, 1, 0B, 0B);
        if (D.19086 != 0) goto <D.19087>; else goto <D.19088>;
        <D.19087>:
        list = monoeg_g_slist_prepend (list, aname);
        goto <D.19089>;
        <D.19088>:
        monoeg_g_free (aname);
        <D.19089>:
      }
    finally
      {
        data = {CLOBBER};
      }
  }
  <D.17514>:
  i = i + 1;
  <D.17516>:
  D.19090 = attrs->num_attrs;
  if (D.19090 > i) goto <D.17515>; else goto <D.17517>;
  <D.17517>:
  mono_custom_attrs_free (attrs);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19091>; else goto <D.19092>;
    <D.19091>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19092>:
    D.19093 = ret != 0;
    D.19094 = (long int) D.19093;
    D.19095 = __builtin_expect (D.19094, 0);
    if (D.19095 != 0) goto <D.19096>; else goto <D.19097>;
    <D.19096>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1654, "ret == 0");
    <D.19097>:
  }
  D.19021 = ass->friend_assembly_names_inited;
  if (D.19021 != 0) goto <D.19098>; else goto <D.19099>;
  <D.19098>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19100>; else goto <D.19101>;
    <D.19100>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19101>:
    D.19102 = ret != 0;
    D.19103 = (long int) D.19102;
    D.19104 = __builtin_expect (D.19103, 0);
    if (D.19104 != 0) goto <D.19105>; else goto <D.19106>;
    <D.19105>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1656, "ret == 0");
    <D.19106>:
  }
  monoeg_g_slist_foreach (list, free_item, 0B);
  monoeg_g_slist_free (list);
  return;
  <D.19099>:
  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.19107>; else goto <D.19108>;
    <D.19107>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19108>:
    D.19109 = ret != 0;
    D.19110 = (long int) D.19109;
    D.19111 = __builtin_expect (D.19110, 0);
    if (D.19111 != 0) goto <D.19112>; else goto <D.19113>;
    <D.19112>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1666, "ret == 0");
    <D.19113>:
  }
}


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

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


mono_assembly_load_from_full (struct MonoImage * image, const char * fname, MonoImageOpenStatus * status, gboolean refonly)
{
  unsigned int D.19119;
  unsigned int D.19120;
  struct MonoAssembly * D.19123;
  struct MonoAssemblyName * D.19124;
  struct MonoImage * D.19125;
  int D.17542;
  int iftmp.41;
  int D.17541;
  const char[9] * D.19131;
  unsigned char D.19132;
  int D.19133;
  unsigned char D.19134;
  int D.19135;
  _Bool D.19136;
  _Bool D.19137;
  _Bool D.19138;
  const unsigned char * D.19141;
  unsigned char D.19142;
  int D.19143;
  const unsigned char * D.19144;
  unsigned char D.19145;
  int D.19146;
  _Bool D.19147;
  _Bool D.19148;
  const unsigned char * D.19151;
  unsigned char D.19152;
  int D.19153;
  const unsigned char * D.19154;
  unsigned char D.19155;
  int D.19156;
  _Bool D.19157;
  _Bool D.19158;
  const unsigned char * D.19161;
  unsigned char D.19162;
  int D.19163;
  const unsigned char * D.19164;
  unsigned char D.19165;
  int D.19166;
  const char * D.19168;
  int D.19171;
  char * D.19172;
  _Bool D.19179;
  long int D.19180;
  long int D.19181;
  struct MonoAssembly * D.19184;
  _Bool D.19189;
  long int D.19190;
  long int D.19191;
  struct GList * loaded_assemblies.42;
  struct GList * loaded_assemblies.43;
  _Bool D.19198;
  long int D.19199;
  long int D.19200;
  struct MonoAssembly * ass;
  struct MonoAssembly * ass2;
  char * base_dir;

  D.19119 = BIT_FIELD_REF <*image, 32, 3904>;
  D.19120 = D.19119 & 16777215;
  if (D.19120 == 0) goto <D.19121>; else goto <D.19122>;
  <D.19121>:
  *status = 3;
  D.19123 = 0B;
  return D.19123;
  <D.19122>:
  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.19124 = &ass->aname;
  mono_assembly_fill_assembly_name (image, D.19124);
  D.19125 = mono_defaults.corlib;
  if (D.19125 != 0B) goto <D.19126>; else goto <D.19127>;
  <D.19126>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ass->aname.name;
      D.19131 = "mscorlib";
      D.19132 = MEM[(const unsigned char *)D.19131];
      D.19133 = (int) D.19132;
      D.19134 = *__s2;
      D.19135 = (int) D.19134;
      __result = D.19133 - D.19135;
      {
        D.19136 = __s2_len != 0;
        D.19137 = __result == 0;
        D.19138 = D.19136 & D.19137;
        if (D.19138 != 0) goto <D.19139>; else goto <D.19140>;
        <D.19139>:
        D.19141 = &MEM[(void *)"mscorlib" + 1B];
        D.19142 = *D.19141;
        D.19143 = (int) D.19142;
        D.19144 = __s2 + 1;
        D.19145 = *D.19144;
        D.19146 = (int) D.19145;
        __result = D.19143 - D.19146;
        D.19147 = __s2_len > 1;
        D.19137 = __result == 0;
        D.19148 = D.19147 & D.19137;
        if (D.19148 != 0) goto <D.19149>; else goto <D.19150>;
        <D.19149>:
        D.19151 = &MEM[(void *)"mscorlib" + 2B];
        D.19152 = *D.19151;
        D.19153 = (int) D.19152;
        D.19154 = __s2 + 2;
        D.19155 = *D.19154;
        D.19156 = (int) D.19155;
        __result = D.19153 - D.19156;
        D.19157 = __s2_len > 2;
        D.19137 = __result == 0;
        D.19158 = D.19157 & D.19137;
        if (D.19158 != 0) goto <D.19159>; else goto <D.19160>;
        <D.19159>:
        D.19161 = &MEM[(void *)"mscorlib" + 3B];
        D.19162 = *D.19161;
        D.19163 = (int) D.19162;
        D.19164 = __s2 + 3;
        D.19165 = *D.19164;
        D.19166 = (int) D.19165;
        __result = D.19163 - D.19166;
        <D.19160>:
        <D.19150>:
        <D.19140>:
      }
      D.17541 = __result;
    }
    iftmp.41 = -D.17541;
    goto <D.19167>;
    <D.19130>:
    D.19168 = ass->aname.name;
    iftmp.41 = __builtin_strcmp (D.19168, "mscorlib");
    <D.19167>:
    D.17542 = iftmp.41;
  }
  if (D.17542 == 0) goto <D.19169>; else goto <D.19170>;
  <D.19169>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  D.19125 = mono_defaults.corlib;
  mono_image_addref (D.19125);
  *status = 0;
  D.19125 = mono_defaults.corlib;
  D.19123 = D.19125->assembly;
  return D.19123;
  <D.19170>:
  <D.19127>:
  mono_image_addref (image);
  D.19171 = image->ref_count;
  D.19172 = image->name;
  D.19168 = ass->aname.name;
  mono_trace (64, 1, "Image addref %s[%p] -> %s[%p]: %d", D.19168, ass, D.19172, image, D.19171);
  D.19168 = ass->aname.name;
  if (D.19168 != 0B) goto <D.19173>; else goto <D.19174>;
  <D.19173>:
  D.19124 = &ass->aname;
  ass2 = mono_assembly_invoke_search_hook_internal (D.19124, refonly, 0);
  if (ass2 != 0B) goto <D.19175>; else goto <D.19176>;
  <D.19175>:
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.19123 = ass2;
  return D.19123;
  <D.19176>:
  <D.19174>:
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19177>; else goto <D.19178>;
    <D.19177>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19178>:
    D.19179 = ret != 0;
    D.19180 = (long int) D.19179;
    D.19181 = __builtin_expect (D.19180, 0);
    if (D.19181 != 0) goto <D.19182>; else goto <D.19183>;
    <D.19182>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1759, "ret == 0");
    <D.19183>:
  }
  D.19184 = image->assembly;
  if (D.19184 != 0B) goto <D.19185>; else goto <D.19186>;
  <D.19185>:
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.19187>; else goto <D.19188>;
    <D.19187>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19188>:
    D.19189 = ret != 0;
    D.19190 = (long int) D.19189;
    D.19191 = __builtin_expect (D.19190, 0);
    if (D.19191 != 0) goto <D.19192>; else goto <D.19193>;
    <D.19192>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1766, "ret == 0");
    <D.19193>:
  }
  ass2 = image->assembly;
  monoeg_g_free (ass);
  monoeg_g_free (base_dir);
  mono_image_close (image);
  *status = 0;
  D.19123 = ass2;
  return D.19123;
  <D.19186>:
  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.19196>; else goto <D.19197>;
    <D.19196>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19197>:
    D.19198 = ret != 0;
    D.19199 = (long int) D.19198;
    D.19200 = __builtin_expect (D.19199, 0);
    if (D.19200 != 0) goto <D.19201>; else goto <D.19202>;
    <D.19201>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 1778, "ret == 0");
    <D.19202>:
  }
  mono_assembly_invoke_load_hook (ass);
  mono_profiler_assembly_loaded (ass, 0);
  D.19123 = ass;
  return D.19123;
}


absolute_dir (const gchar * filename)
{
  int D.19204;
  gchar * D.19207;
  int D.17434;
  int iftmp.44;
  int D.17433;
  const char[2] * D.19211;
  unsigned char D.19212;
  int D.19213;
  unsigned char D.19214;
  int D.19215;
  _Bool D.19216;
  _Bool D.19217;
  _Bool D.19218;
  const unsigned char * D.19221;
  unsigned char D.19222;
  int D.19223;
  const unsigned char * D.19224;
  unsigned char D.19225;
  int D.19226;
  _Bool D.19227;
  _Bool D.19228;
  const unsigned char * D.19231;
  unsigned char D.19232;
  int D.19233;
  const unsigned char * D.19234;
  unsigned char D.19235;
  int D.19236;
  _Bool D.19237;
  _Bool D.19238;
  const unsigned char * D.19241;
  unsigned char D.19242;
  int D.19243;
  const unsigned char * D.19244;
  unsigned char D.19245;
  int D.19246;
  int D.17444;
  int iftmp.45;
  int D.17443;
  const char[3] * D.19253;
  unsigned char D.19254;
  int D.19255;
  unsigned char D.19256;
  int D.19257;
  _Bool D.19258;
  _Bool D.19259;
  _Bool D.19260;
  const unsigned char * D.19263;
  unsigned char D.19264;
  int D.19265;
  const unsigned char * D.19266;
  unsigned char D.19267;
  int D.19268;
  _Bool D.19269;
  _Bool D.19270;
  const unsigned char * D.19273;
  unsigned char D.19274;
  int D.19275;
  const unsigned char * D.19276;
  unsigned char D.19277;
  int D.19278;
  _Bool D.19279;
  _Bool D.19280;
  const unsigned char * D.19283;
  unsigned char D.19284;
  int D.19285;
  const unsigned char * D.19286;
  unsigned char D.19287;
  int D.19288;
  struct GList * D.19294;
  unsigned int i.46;
  unsigned int D.19299;
  gchar * * D.19300;
  void * D.19301;
  struct GList * D.19305;
  char D.19306;
  gchar * cwd;
  gchar * mixed;
  gchar * * parts;
  gchar * part;
  struct GList * list;
  struct GList * tmp;
  struct GString * result;
  gchar * res;
  gint i;

  D.19204 = monoeg_g_path_is_absolute (filename);
  if (D.19204 != 0) goto <D.19205>; else goto <D.19206>;
  <D.19205>:
  part = monoeg_g_path_get_dirname (filename);
  res = monoeg_g_strconcat (part, "/", 0B);
  monoeg_g_free (part);
  D.19207 = res;
  return D.19207;
  <D.19206>:
  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.17446>;
  <D.17445>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = part;
      D.19211 = ".";
      D.19212 = MEM[(const unsigned char *)D.19211];
      D.19213 = (int) D.19212;
      D.19214 = *__s2;
      D.19215 = (int) D.19214;
      __result = D.19213 - D.19215;
      {
        D.19216 = __s2_len != 0;
        D.19217 = __result == 0;
        D.19218 = D.19216 & D.19217;
        if (D.19218 != 0) goto <D.19219>; else goto <D.19220>;
        <D.19219>:
        D.19221 = &MEM[(void *)"." + 1B];
        D.19222 = *D.19221;
        D.19223 = (int) D.19222;
        D.19224 = __s2 + 1;
        D.19225 = *D.19224;
        D.19226 = (int) D.19225;
        __result = D.19223 - D.19226;
        D.19227 = __s2_len > 1;
        D.19217 = __result == 0;
        D.19228 = D.19227 & D.19217;
        if (D.19228 != 0) goto <D.19229>; else goto <D.19230>;
        <D.19229>:
        D.19231 = &MEM[(void *)"." + 2B];
        D.19232 = *D.19231;
        D.19233 = (int) D.19232;
        D.19234 = __s2 + 2;
        D.19235 = *D.19234;
        D.19236 = (int) D.19235;
        __result = D.19233 - D.19236;
        D.19237 = __s2_len > 2;
        D.19217 = __result == 0;
        D.19238 = D.19237 & D.19217;
        if (D.19238 != 0) goto <D.19239>; else goto <D.19240>;
        <D.19239>:
        D.19241 = &MEM[(void *)"." + 3B];
        D.19242 = *D.19241;
        D.19243 = (int) D.19242;
        D.19244 = __s2 + 3;
        D.19245 = *D.19244;
        D.19246 = (int) D.19245;
        __result = D.19243 - D.19246;
        <D.19240>:
        <D.19230>:
        <D.19220>:
      }
      D.17433 = __result;
    }
    iftmp.44 = -D.17433;
    goto <D.19247>;
    <D.19210>:
    iftmp.44 = __builtin_strcmp (part, ".");
    <D.19247>:
    D.17434 = iftmp.44;
  }
  if (D.17434 == 0) goto <D.19248>; else goto <D.19249>;
  <D.19248>:
  // predicted unlikely by continue predictor.
  goto <D.17435>;
  <D.19249>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = part;
      D.19253 = "..";
      D.19254 = MEM[(const unsigned char *)D.19253];
      D.19255 = (int) D.19254;
      D.19256 = *__s2;
      D.19257 = (int) D.19256;
      __result = D.19255 - D.19257;
      {
        D.19258 = __s2_len != 0;
        D.19259 = __result == 0;
        D.19260 = D.19258 & D.19259;
        if (D.19260 != 0) goto <D.19261>; else goto <D.19262>;
        <D.19261>:
        D.19263 = &MEM[(void *)".." + 1B];
        D.19264 = *D.19263;
        D.19265 = (int) D.19264;
        D.19266 = __s2 + 1;
        D.19267 = *D.19266;
        D.19268 = (int) D.19267;
        __result = D.19265 - D.19268;
        D.19269 = __s2_len > 1;
        D.19259 = __result == 0;
        D.19270 = D.19269 & D.19259;
        if (D.19270 != 0) goto <D.19271>; else goto <D.19272>;
        <D.19271>:
        D.19273 = &MEM[(void *)".." + 2B];
        D.19274 = *D.19273;
        D.19275 = (int) D.19274;
        D.19276 = __s2 + 2;
        D.19277 = *D.19276;
        D.19278 = (int) D.19277;
        __result = D.19275 - D.19278;
        D.19279 = __s2_len > 2;
        D.19259 = __result == 0;
        D.19280 = D.19279 & D.19259;
        if (D.19280 != 0) goto <D.19281>; else goto <D.19282>;
        <D.19281>:
        D.19283 = &MEM[(void *)".." + 3B];
        D.19284 = *D.19283;
        D.19285 = (int) D.19284;
        D.19286 = __s2 + 3;
        D.19287 = *D.19286;
        D.19288 = (int) D.19287;
        __result = D.19285 - D.19288;
        <D.19282>:
        <D.19272>:
        <D.19262>:
      }
      D.17443 = __result;
    }
    iftmp.45 = -D.17443;
    goto <D.19289>;
    <D.19252>:
    iftmp.45 = __builtin_strcmp (part, "..");
    <D.19289>:
    D.17444 = iftmp.45;
  }
  if (D.17444 == 0) goto <D.19290>; else goto <D.19291>;
  <D.19290>:
  if (list != 0B) goto <D.19292>; else goto <D.19293>;
  <D.19292>:
  D.19294 = list->next;
  if (D.19294 != 0B) goto <D.19295>; else goto <D.19296>;
  <D.19295>:
  list = monoeg_g_list_delete_link (list, list);
  <D.19296>:
  <D.19293>:
  goto <D.19297>;
  <D.19291>:
  list = monoeg_g_list_prepend (list, part);
  <D.19297>:
  <D.17435>:
  i = i + 1;
  <D.17446>:
  i.46 = (unsigned int) i;
  D.19299 = i.46 * 4;
  D.19300 = parts + D.19299;
  part = *D.19300;
  if (part != 0B) goto <D.17445>; else goto <D.17447>;
  <D.17447>:
  result = monoeg_g_string_new ("");
  list = monoeg_g_list_reverse (list);
  tmp = list;
  goto <D.17449>;
  <D.17448>:
  D.19301 = tmp->data;
  if (D.19301 != 0B) goto <D.19302>; else goto <D.19303>;
  <D.19302>:
  D.19301 = tmp->data;
  monoeg_g_string_append_printf (result, "%s%c", D.19301, 47);
  <D.19303>:
  tmp = tmp->next;
  <D.17449>:
  if (tmp != 0B) goto <D.19304>; else goto <D.17450>;
  <D.19304>:
  D.19305 = tmp->next;
  if (D.19305 != 0B) goto <D.17448>; else goto <D.17450>;
  <D.17450>:
  res = result->str;
  monoeg_g_string_free (result, 0);
  monoeg_g_list_free (list);
  monoeg_g_strfreev (parts);
  D.19306 = *res;
  if (D.19306 == 0) goto <D.19307>; else goto <D.19308>;
  <D.19307>:
  monoeg_g_free (res);
  D.19207 = monoeg_strdup (".");
  return D.19207;
  <D.19308>:
  D.19207 = res;
  return D.19207;
}


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

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


mono_assembly_name_free (struct MonoAssemblyName * aname)
{
  const char * D.19314;
  const char * D.19315;
  const char * D.19316;

  if (aname == 0B) goto <D.19312>; else goto <D.19313>;
  <D.19312>:
  return;
  <D.19313>:
  D.19314 = aname->name;
  monoeg_g_free (D.19314);
  D.19315 = aname->culture;
  monoeg_g_free (D.19315);
  D.19316 = aname->hash_value;
  monoeg_g_free (D.19316);
}


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.19325;
  gboolean D.19326;
  gchar * D.19327;
  gchar * D.19328;
  gchar * D.19329;
  int D.19330;
  unsigned int part_name_len.47;
  gchar * part_name.48;
  int D.19336;
  char D.19339;
  int D.19343;
  char D.19346;
  int D.19350;
  char D.19353;
  int D.19357;
  char D.19360;
  int D.19364;
  char D.19367;
  int D.19369;
  int D.19373;
  int D.19377;
  gchar * value.49;
  int D.19381;
  int D.19385;
  int D.19389;
  int D.19393;
  int D.19397;
  _Bool D.19401;
  _Bool D.19402;
  _Bool D.19403;
  _Bool D.19405;
  _Bool D.19406;
  _Bool D.19407;
  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.19318>; else goto <D.19319>;
      <D.19318>:
      is_version_defined = &version_defined;
      <D.19319>:
      *is_version_defined = 0;
      if (is_token_defined == 0B) goto <D.19320>; else goto <D.19321>;
      <D.19320>:
      is_token_defined = &token_defined;
      <D.19321>:
      *is_token_defined = 0;
      tmp = monoeg_g_strsplit (name, ",", 6);
      parts = tmp;
      if (tmp == 0B) goto <D.19322>; else goto <D.19324>;
      <D.19324>:
      D.19325 = *tmp;
      if (D.19325 == 0B) goto <D.19322>; else goto <D.19323>;
      <D.19322>:
      monoeg_g_strfreev (tmp);
      D.19326 = 0;
      return D.19326;
      <D.19323>:
      D.19325 = *tmp;
      D.19327 = monoeg_g_strchomp (D.19325);
      dllname = monoeg_g_strchug (D.19327);
      tmp = tmp + 4;
      goto <D.17670>;
      <D.17671>:
      D.19325 = *tmp;
      D.19328 = monoeg_g_strchomp (D.19325);
      D.19329 = monoeg_g_strchug (D.19328);
      D.19330 = split_key_value (D.19329, &part_name, &part_name_len, &value);
      if (D.19330 == 0) goto cleanup_and_fail; else goto <D.19331>;
      <D.19331>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 7) goto <D.19333>; else goto <D.19334>;
      <D.19333>:
      part_name_len.47 = part_name_len;
      part_name.48 = part_name;
      D.19336 = monoeg_g_ascii_strncasecmp (part_name.48, "Version", part_name_len.47);
      if (D.19336 == 0) goto <D.19337>; else goto <D.19338>;
      <D.19337>:
      *is_version_defined = 1;
      version = value;
      D.19339 = MEM[(const char *)version];
      if (D.19339 == 0) goto cleanup_and_fail; else goto <D.19340>;
      <D.19340>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.17670>;
      <D.19338>:
      <D.19334>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 7) goto <D.19341>; else goto <D.19342>;
      <D.19341>:
      part_name_len.47 = part_name_len;
      part_name.48 = part_name;
      D.19343 = monoeg_g_ascii_strncasecmp (part_name.48, "Culture", part_name_len.47);
      if (D.19343 == 0) goto <D.19344>; else goto <D.19345>;
      <D.19344>:
      culture = value;
      D.19346 = MEM[(const char *)culture];
      if (D.19346 == 0) goto cleanup_and_fail; else goto <D.19347>;
      <D.19347>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.17670>;
      <D.19345>:
      <D.19342>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 14) goto <D.19348>; else goto <D.19349>;
      <D.19348>:
      part_name_len.47 = part_name_len;
      part_name.48 = part_name;
      D.19350 = monoeg_g_ascii_strncasecmp (part_name.48, "PublicKeyToken", part_name_len.47);
      if (D.19350 == 0) goto <D.19351>; else goto <D.19352>;
      <D.19351>:
      *is_token_defined = 1;
      token = value;
      D.19353 = MEM[(const char *)token];
      if (D.19353 == 0) goto cleanup_and_fail; else goto <D.19354>;
      <D.19354>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.17670>;
      <D.19352>:
      <D.19349>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 9) goto <D.19355>; else goto <D.19356>;
      <D.19355>:
      part_name_len.47 = part_name_len;
      part_name.48 = part_name;
      D.19357 = monoeg_g_ascii_strncasecmp (part_name.48, "PublicKey", part_name_len.47);
      if (D.19357 == 0) goto <D.19358>; else goto <D.19359>;
      <D.19358>:
      key = value;
      D.19360 = MEM[(const char *)key];
      if (D.19360 == 0) goto cleanup_and_fail; else goto <D.19361>;
      <D.19361>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.17670>;
      <D.19359>:
      <D.19356>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 12) goto <D.19362>; else goto <D.19363>;
      <D.19362>:
      part_name_len.47 = part_name_len;
      part_name.48 = part_name;
      D.19364 = monoeg_g_ascii_strncasecmp (part_name.48, "Retargetable", part_name_len.47);
      if (D.19364 == 0) goto <D.19365>; else goto <D.19366>;
      <D.19365>:
      retargetable = value;
      D.19367 = MEM[(const char *)retargetable];
      if (D.19367 == 0) goto cleanup_and_fail; else goto <D.19368>;
      <D.19368>:
      D.19369 = monoeg_ascii_strcasecmp (retargetable, "yes");
      if (D.19369 == 0) goto <D.19370>; else goto <D.19371>;
      <D.19370>:
      flags = flags | 256;
      goto <D.19372>;
      <D.19371>:
      D.19373 = monoeg_ascii_strcasecmp (retargetable, "no");
      if (D.19373 != 0) goto cleanup_and_fail; else goto <D.19374>;
      <D.19374>:
      <D.19372>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.17670>;
      <D.19366>:
      <D.19363>:
      part_name_len.47 = part_name_len;
      if (part_name_len.47 == 21) goto <D.19375>; else goto <D.19376>;
      <D.19375>:
      part_name_len.47 = part_name_len;
      part_name.48 = part_name;
      D.19377 = monoeg_g_ascii_strncasecmp (part_name.48, "ProcessorArchitecture", part_name_len.47);
      if (D.19377 == 0) goto <D.19378>; else goto <D.19379>;
      <D.19378>:
      value.49 = value;
      D.19381 = monoeg_ascii_strcasecmp (value.49, "None");
      if (D.19381 == 0) goto <D.19382>; else goto <D.19383>;
      <D.19382>:
      arch = 0;
      goto <D.19384>;
      <D.19383>:
      value.49 = value;
      D.19385 = monoeg_ascii_strcasecmp (value.49, "MSIL");
      if (D.19385 == 0) goto <D.19386>; else goto <D.19387>;
      <D.19386>:
      arch = 1;
      goto <D.19388>;
      <D.19387>:
      value.49 = value;
      D.19389 = monoeg_ascii_strcasecmp (value.49, "X86");
      if (D.19389 == 0) goto <D.19390>; else goto <D.19391>;
      <D.19390>:
      arch = 2;
      goto <D.19392>;
      <D.19391>:
      value.49 = value;
      D.19393 = monoeg_ascii_strcasecmp (value.49, "IA64");
      if (D.19393 == 0) goto <D.19394>; else goto <D.19395>;
      <D.19394>:
      arch = 3;
      goto <D.19396>;
      <D.19395>:
      value.49 = value;
      D.19397 = monoeg_ascii_strcasecmp (value.49, "AMD64");
      if (D.19397 == 0) goto <D.19398>; else goto cleanup_and_fail;
      <D.19398>:
      arch = 4;
      <D.19396>:
      <D.19392>:
      <D.19388>:
      <D.19384>:
      tmp = tmp + 4;
      // predicted unlikely by continue predictor.
      goto <D.17670>;
      <D.19379>:
      <D.19376>:
      monoeg_g_strfreev (parts);
      D.19326 = 0;
      return D.19326;
      <D.17670>:
      D.19325 = *tmp;
      if (D.19325 != 0B) goto <D.17671>; else goto <D.17672>;
      <D.17672>:
      if (retargetable != 0B) goto <D.19399>; else goto <D.19400>;
      <D.19399>:
      D.19401 = version == 0B;
      D.19402 = culture == 0B;
      D.19403 = D.19401 | D.19402;
      if (D.19403 != 0) goto cleanup_and_fail; else goto <D.19404>;
      <D.19404>:
      D.19405 = key == 0B;
      D.19406 = token == 0B;
      D.19407 = D.19405 & D.19406;
      if (D.19407 != 0) goto cleanup_and_fail; else goto <D.19408>;
      <D.19408>:
      <D.19400>:
      res = build_assembly_name (dllname, version, culture, token, key, flags, arch, aname, save_public_key);
      monoeg_g_strfreev (parts);
      D.19326 = res;
      return D.19326;
      cleanup_and_fail:
      monoeg_g_strfreev (parts);
      D.19326 = 0;
      return D.19326;
    }
  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.19413;
  int eqsign.50;
  gchar * D.19415;
  int D.19416;
  int D.19417;
  unsigned int D.19418;
  unsigned int D.19419;
  unsigned int D.19420;
  const short unsigned int * * D.19422;
  const short unsigned int * D.19423;
  sizetype D.19424;
  gchar * D.19425;
  char D.19426;
  unsigned int D.19427;
  unsigned int D.19428;
  const short unsigned int * D.19429;
  short unsigned int D.19430;
  int D.19431;
  int D.19432;
  gchar * D.19433;
  gchar * D.19434;
  gchar * D.19435;
  char * eqsign;

  eqsign = __builtin_strchr (pair, 61);
  if (eqsign == 0B) goto <D.19411>; else goto <D.19412>;
  <D.19411>:
  *key = 0B;
  *keylen = 0;
  *value = 0B;
  D.19413 = 0;
  return D.19413;
  <D.19412>:
  *key = pair;
  eqsign.50 = (int) eqsign;
  D.19415 = *key;
  D.19416 = (int) D.19415;
  D.19417 = eqsign.50 - D.19416;
  D.19418 = (unsigned int) D.19417;
  *keylen = D.19418;
  goto <D.17644>;
  <D.17643>:
  D.19419 = *keylen;
  D.19420 = D.19419 + 4294967295;
  *keylen = D.19420;
  <D.17644>:
  D.19419 = *keylen;
  if (D.19419 != 0) goto <D.19421>; else goto <D.17645>;
  <D.19421>:
  D.19422 = __ctype_b_loc ();
  D.19423 = *D.19422;
  D.19415 = *key;
  D.19419 = *keylen;
  D.19424 = D.19419 + 4294967295;
  D.19425 = D.19415 + D.19424;
  D.19426 = *D.19425;
  D.19427 = (unsigned int) D.19426;
  D.19428 = D.19427 * 2;
  D.19429 = D.19423 + D.19428;
  D.19430 = *D.19429;
  D.19431 = (int) D.19430;
  D.19432 = D.19431 & 8192;
  if (D.19432 != 0) goto <D.17643>; else goto <D.17645>;
  <D.17645>:
  D.19433 = eqsign + 1;
  D.19434 = monoeg_g_strchomp (D.19433);
  D.19435 = monoeg_g_strchug (D.19434);
  *value = D.19435;
  D.19413 = 1;
  return D.19413;
}


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.19440;
  gboolean D.19443;
  int major.52;
  short unsigned int D.19445;
  int minor.53;
  short unsigned int D.19447;
  int build.54;
  short unsigned int D.19451;
  int revision.55;
  short unsigned int D.19456;
  short unsigned int D.19458;
  gchar * D.19459;
  int D.19462;
  gchar * D.19465;
  gchar * D.19467;
  int D.19470;
  unsigned int D.19473;
  mono_byte[17] * D.19476;
  int D.17628;
  int iftmp.56;
  int D.17627;
  const char[5] * D.19484;
  unsigned char D.19485;
  int D.19486;
  unsigned char D.19487;
  int D.19488;
  _Bool D.19489;
  _Bool D.19490;
  _Bool D.19491;
  const unsigned char * D.19494;
  unsigned char D.19495;
  int D.19496;
  const unsigned char * D.19497;
  unsigned char D.19498;
  int D.19499;
  _Bool D.19500;
  _Bool D.19501;
  const unsigned char * D.19504;
  unsigned char D.19505;
  int D.19506;
  const unsigned char * D.19507;
  unsigned char D.19508;
  int D.19509;
  _Bool D.19510;
  _Bool D.19511;
  const unsigned char * D.19514;
  unsigned char D.19515;
  int D.19516;
  const unsigned char * D.19517;
  unsigned char D.19518;
  int D.19519;
  int D.19522;
  int is_ecma.57;
  gchar * pkey.58;
  unsigned int D.19530;
  unsigned int len.59;
  gchar * pkeyptr.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.19437>; else goto <D.19438>;
      <D.19437>:
      version_parts = sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision);
      version_parts.51 = (unsigned int) version_parts;
      D.19440 = version_parts.51 + 4294967294;
      if (D.19440 > 2) goto <D.19441>; else goto <D.19442>;
      <D.19441>:
      D.19443 = 0;
      return D.19443;
      <D.19442>:
      major.52 = major;
      D.19445 = (short unsigned int) major.52;
      aname->major = D.19445;
      minor.53 = minor;
      D.19447 = (short unsigned int) minor.53;
      aname->minor = D.19447;
      if (version_parts > 2) goto <D.19448>; else goto <D.19449>;
      <D.19448>:
      build.54 = build;
      D.19451 = (short unsigned int) build.54;
      aname->build = D.19451;
      goto <D.19452>;
      <D.19449>:
      aname->build = 0;
      <D.19452>:
      if (version_parts == 4) goto <D.19453>; else goto <D.19454>;
      <D.19453>:
      revision.55 = revision;
      D.19456 = (short unsigned int) revision.55;
      aname->revision = D.19456;
      goto <D.19457>;
      <D.19454>:
      aname->revision = 0;
      <D.19457>:
      <D.19438>:
      aname->flags = flags;
      D.19458 = (short unsigned int) arch;
      aname->arch = D.19458;
      D.19459 = monoeg_strdup (name);
      aname->name = D.19459;
      if (culture != 0B) goto <D.19460>; else goto <D.19461>;
      <D.19460>:
      D.19462 = monoeg_ascii_strcasecmp (culture, "neutral");
      if (D.19462 == 0) goto <D.19463>; else goto <D.19464>;
      <D.19463>:
      D.19465 = monoeg_strdup ("");
      aname->culture = D.19465;
      goto <D.19466>;
      <D.19464>:
      D.19467 = monoeg_strdup (culture);
      aname->culture = D.19467;
      <D.19466>:
      <D.19461>:
      if (token != 0B) goto <D.19468>; else goto <D.19469>;
      <D.19468>:
      D.19470 = strncmp (token, "null", 4);
      if (D.19470 != 0) goto <D.19471>; else goto <D.19472>;
      <D.19471>:
      {
        char * lower;

        D.19473 = strlen (token);
        if (D.19473 != 16) goto <D.19474>; else goto <D.19475>;
        <D.19474>:
        mono_assembly_name_free (aname);
        D.19443 = 0;
        return D.19443;
        <D.19475>:
        lower = monoeg_g_ascii_strdown (token, 17);
        D.19476 = &aname->public_key_token;
        monoeg_g_strlcpy (D.19476, lower, 17);
        monoeg_g_free (lower);
      }
      <D.19472>:
      <D.19469>:
      if (key != 0B) goto <D.19477>; else goto <D.19478>;
      <D.19477>:
      {
        gboolean is_ecma;

        try
          {
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = key;
                D.19484 = "null";
                D.19485 = MEM[(const unsigned char *)D.19484];
                D.19486 = (int) D.19485;
                D.19487 = *__s2;
                D.19488 = (int) D.19487;
                __result = D.19486 - D.19488;
                {
                  D.19489 = __s2_len != 0;
                  D.19490 = __result == 0;
                  D.19491 = D.19489 & D.19490;
                  if (D.19491 != 0) goto <D.19492>; else goto <D.19493>;
                  <D.19492>:
                  D.19494 = &MEM[(void *)"null" + 1B];
                  D.19495 = *D.19494;
                  D.19496 = (int) D.19495;
                  D.19497 = __s2 + 1;
                  D.19498 = *D.19497;
                  D.19499 = (int) D.19498;
                  __result = D.19496 - D.19499;
                  D.19500 = __s2_len > 1;
                  D.19490 = __result == 0;
                  D.19501 = D.19500 & D.19490;
                  if (D.19501 != 0) goto <D.19502>; else goto <D.19503>;
                  <D.19502>:
                  D.19504 = &MEM[(void *)"null" + 2B];
                  D.19505 = *D.19504;
                  D.19506 = (int) D.19505;
                  D.19507 = __s2 + 2;
                  D.19508 = *D.19507;
                  D.19509 = (int) D.19508;
                  __result = D.19506 - D.19509;
                  D.19510 = __s2_len > 2;
                  D.19490 = __result == 0;
                  D.19511 = D.19510 & D.19490;
                  if (D.19511 != 0) goto <D.19512>; else goto <D.19513>;
                  <D.19512>:
                  D.19514 = &MEM[(void *)"null" + 3B];
                  D.19515 = *D.19514;
                  D.19516 = (int) D.19515;
                  D.19517 = __s2 + 3;
                  D.19518 = *D.19517;
                  D.19519 = (int) D.19518;
                  __result = D.19516 - D.19519;
                  <D.19513>:
                  <D.19503>:
                  <D.19493>:
                }
                D.17627 = __result;
              }
              iftmp.56 = -D.17627;
              goto <D.19520>;
              <D.19483>:
              iftmp.56 = __builtin_strcmp (key, "null");
              <D.19520>:
              D.17628 = iftmp.56;
            }
            if (D.17628 == 0) goto <D.19479>; else goto <D.19521>;
            <D.19521>:
            D.19522 = parse_public_key (key, &pkey, &is_ecma);
            if (D.19522 == 0) goto <D.19479>; else goto <D.19480>;
            <D.19479>:
            mono_assembly_name_free (aname);
            D.19443 = 0;
            return D.19443;
            <D.19480>:
            is_ecma.57 = is_ecma;
            if (is_ecma.57 != 0) goto <D.19524>; else goto <D.19525>;
            <D.19524>:
            if (save_public_key != 0) goto <D.19526>; else goto <D.19527>;
            <D.19526>:
            pkey.58 = pkey;
            aname->public_key = pkey.58;
            goto <D.19529>;
            <D.19527>:
            pkey.58 = pkey;
            monoeg_g_free (pkey.58);
            <D.19529>:
            D.19476 = &aname->public_key_token;
            monoeg_g_strlcpy (D.19476, "b77a5c561934e089", 17);
            D.19443 = 1;
            return D.19443;
            <D.19525>:
            pkey.58 = pkey;
            D.19530 = mono_metadata_decode_blob_size (pkey.58, &pkeyptr);
            len = (gint) D.19530;
            len.59 = (unsigned int) len;
            pkeyptr.60 = pkeyptr;
            mono_digest_get_public_token (&tok, pkeyptr.60, len.59);
            encoded = encode_public_tok (&tok, 8);
            D.19476 = &aname->public_key_token;
            monoeg_g_strlcpy (D.19476, encoded, 17);
            monoeg_g_free (encoded);
            if (save_public_key != 0) goto <D.19533>; else goto <D.19534>;
            <D.19533>:
            pkey.58 = pkey;
            aname->public_key = pkey.58;
            goto <D.19535>;
            <D.19534>:
            pkey.58 = pkey;
            monoeg_g_free (pkey.58);
            <D.19535>:
          }
        finally
          {
            is_ecma = {CLOBBER};
          }
      }
      <D.19478>:
      D.19443 = 1;
      return D.19443;
    }
  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.19540;
  unsigned int D.19541;
  gboolean D.19544;
  int D.17577;
  int iftmp.61;
  int D.17576;
  const char[33] * D.19548;
  unsigned char D.19549;
  int D.19550;
  unsigned char D.19551;
  int D.19552;
  _Bool D.19553;
  _Bool D.19554;
  _Bool D.19555;
  const unsigned char * D.19558;
  unsigned char D.19559;
  int D.19560;
  const unsigned char * D.19561;
  unsigned char D.19562;
  int D.19563;
  _Bool D.19564;
  _Bool D.19565;
  const unsigned char * D.19568;
  unsigned char D.19569;
  int D.19570;
  const unsigned char * D.19571;
  unsigned char D.19572;
  int D.19573;
  _Bool D.19574;
  _Bool D.19575;
  const unsigned char * D.19578;
  unsigned char D.19579;
  int D.19580;
  const unsigned char * D.19581;
  unsigned char D.19582;
  int D.19583;
  gchar * D.19589;
  char D.19590;
  int D.19591;
  int D.19592;
  int D.19593;
  const gchar * D.19594;
  char D.19595;
  int D.19596;
  int D.19597;
  char D.19598;
  int D.19599;
  const gchar * D.19602;
  char D.19603;
  int D.19604;
  int D.19605;
  const gchar * D.19606;
  char D.19607;
  int D.19608;
  int D.19609;
  char D.19610;
  unsigned int D.19613;
  unsigned int D.19614;
  int j.62;
  sizetype j.63;
  const gchar * D.19619;
  char D.19620;
  int D.19621;
  int D.19622;
  int D.19623;
  char D.19624;
  int j.64;
  sizetype j.65;
  const gchar * D.19627;
  char D.19628;
  int D.19629;
  int D.19630;
  char D.19631;
  char D.19632;
  char D.19633;
  char D.19636;
  char D.19638;
  char D.19640;
  char D.19642;
  const guint32 * D.19644;
  unsigned int D.19645;
  const guint32 * D.19646;
  unsigned int D.19647;
  unsigned int D.19648;
  int D.19649;
  int D.19656;
  unsigned int D.19657;
  int offset.66;
  sizetype offset.67;
  gchar * D.19660;
  char D.19661;
  int D.19663;
  unsigned int D.19664;
  int offset.68;
  sizetype offset.69;
  gchar * D.19667;
  int offset.70;
  sizetype offset.71;
  gchar * D.19670;
  sizetype i.72;
  gchar * D.19672;
  int j.73;
  sizetype j.74;
  const gchar * D.19675;
  char D.19676;
  int D.19677;
  int D.19678;
  int D.19679;
  char D.19680;
  int j.75;
  sizetype j.76;
  const gchar * D.19683;
  char D.19684;
  int D.19685;
  int D.19686;
  char D.19687;
  char D.19688;
  char D.19689;
  int D.19690;
  const gchar * pkey;
  gchar header[16];
  gchar val;
  gchar * arr;
  gint i;
  gint j;
  gint offset;
  gint bitlen;
  gint keylen;
  gint pkeylen;

  try
    {
      D.19540 = strlen (key);
      D.19541 = D.19540 >> 1;
      keylen = (gint) D.19541;
      if (keylen <= 0) goto <D.19542>; else goto <D.19543>;
      <D.19542>:
      D.19544 = 0;
      return D.19544;
      <D.19543>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = key;
          D.19548 = "00000000000000000400000000000000";
          D.19549 = MEM[(const unsigned char *)D.19548];
          D.19550 = (int) D.19549;
          D.19551 = *__s2;
          D.19552 = (int) D.19551;
          __result = D.19550 - D.19552;
          {
            D.19553 = __s2_len != 0;
            D.19554 = __result == 0;
            D.19555 = D.19553 & D.19554;
            if (D.19555 != 0) goto <D.19556>; else goto <D.19557>;
            <D.19556>:
            D.19558 = &MEM[(void *)"00000000000000000400000000000000" + 1B];
            D.19559 = *D.19558;
            D.19560 = (int) D.19559;
            D.19561 = __s2 + 1;
            D.19562 = *D.19561;
            D.19563 = (int) D.19562;
            __result = D.19560 - D.19563;
            D.19564 = __s2_len > 1;
            D.19554 = __result == 0;
            D.19565 = D.19564 & D.19554;
            if (D.19565 != 0) goto <D.19566>; else goto <D.19567>;
            <D.19566>:
            D.19568 = &MEM[(void *)"00000000000000000400000000000000" + 2B];
            D.19569 = *D.19568;
            D.19570 = (int) D.19569;
            D.19571 = __s2 + 2;
            D.19572 = *D.19571;
            D.19573 = (int) D.19572;
            __result = D.19570 - D.19573;
            D.19574 = __s2_len > 2;
            D.19554 = __result == 0;
            D.19575 = D.19574 & D.19554;
            if (D.19575 != 0) goto <D.19576>; else goto <D.19577>;
            <D.19576>:
            D.19578 = &MEM[(void *)"00000000000000000400000000000000" + 3B];
            D.19579 = *D.19578;
            D.19580 = (int) D.19579;
            D.19581 = __s2 + 3;
            D.19582 = *D.19581;
            D.19583 = (int) D.19582;
            __result = D.19580 - D.19583;
            <D.19577>:
            <D.19567>:
            <D.19557>:
          }
          D.17576 = __result;
        }
        iftmp.61 = -D.17576;
        goto <D.19584>;
        <D.19547>:
        iftmp.61 = __builtin_strcmp (key, "00000000000000000400000000000000");
        <D.19584>:
        D.17577 = iftmp.61;
      }
      if (D.17577 == 0) goto <D.19585>; else goto <D.19586>;
      <D.19585>:
      if (pubkey != 0B) goto <D.19587>; else goto <D.19588>;
      <D.19587>:
      D.19589 = monoeg_strdup (key);
      *pubkey = D.19589;
      *is_ecma = 1;
      <D.19588>:
      D.19544 = 1;
      return D.19544;
      <D.19586>:
      *is_ecma = 0;
      D.19590 = *key;
      D.19591 = (int) D.19590;
      D.19592 = monoeg_g_ascii_xdigit_value (D.19591);
      D.19593 = D.19592 << 4;
      val = (gchar) D.19593;
      D.19594 = key + 1;
      D.19595 = *D.19594;
      D.19596 = (int) D.19595;
      D.19597 = monoeg_g_ascii_xdigit_value (D.19596);
      D.19598 = (char) D.19597;
      val = D.19598 | val;
      D.19599 = (int) val;
      switch (D.19599) <default: <D.17581>, case 0: <D.17578>, case 6: <D.17580>>
      <D.17578>:
      if (keylen <= 12) goto <D.19600>; else goto <D.19601>;
      <D.19600>:
      D.19544 = 0;
      return D.19544;
      <D.19601>:
      D.19602 = key + 24;
      D.19603 = *D.19602;
      D.19604 = (int) D.19603;
      D.19605 = monoeg_g_ascii_xdigit_value (D.19604);
      val = (gchar) D.19605;
      D.19606 = key + 25;
      D.19607 = *D.19606;
      D.19608 = (int) D.19607;
      D.19609 = monoeg_g_ascii_xdigit_value (D.19608);
      D.19610 = (char) D.19609;
      val = D.19610 | val;
      if (val != 6) goto <D.19611>; else goto <D.19612>;
      <D.19611>:
      D.19544 = 0;
      return D.19544;
      <D.19612>:
      pkey = key + 24;
      goto <D.17579>;
      <D.17580>:
      pkey = key;
      goto <D.17579>;
      <D.17581>:
      D.19544 = 0;
      return D.19544;
      <D.17579>:
      D.19613 = strlen (pkey);
      D.19614 = D.19613 >> 1;
      pkeylen = (gint) D.19614;
      if (pkeylen <= 15) goto <D.19615>; else goto <D.19616>;
      <D.19615>:
      D.19544 = 0;
      return D.19544;
      <D.19616>:
      i = 0;
      j = 0;
      goto <D.17583>;
      <D.17582>:
      j.62 = j;
      j = j.62 + 1;
      j.63 = (sizetype) j.62;
      D.19619 = pkey + j.63;
      D.19620 = *D.19619;
      D.19621 = (int) D.19620;
      D.19622 = monoeg_g_ascii_xdigit_value (D.19621);
      D.19623 = D.19622 << 4;
      D.19624 = (char) D.19623;
      header[i] = D.19624;
      j.64 = j;
      j = j.64 + 1;
      j.65 = (sizetype) j.64;
      D.19627 = pkey + j.65;
      D.19628 = *D.19627;
      D.19629 = (int) D.19628;
      D.19630 = monoeg_g_ascii_xdigit_value (D.19629);
      D.19631 = header[i];
      D.19632 = (char) D.19630;
      D.19633 = D.19631 | D.19632;
      header[i] = D.19633;
      i = i + 1;
      <D.17583>:
      if (i <= 15) goto <D.17582>; else goto <D.17584>;
      <D.17584>:
      D.19636 = header[0];
      if (D.19636 != 6) goto <D.19634>; else goto <D.19637>;
      <D.19637>:
      D.19638 = header[1];
      if (D.19638 != 2) goto <D.19634>; else goto <D.19639>;
      <D.19639>:
      D.19640 = header[2];
      if (D.19640 != 0) goto <D.19634>; else goto <D.19641>;
      <D.19641>:
      D.19642 = header[3];
      if (D.19642 != 0) goto <D.19634>; else goto <D.19643>;
      <D.19643>:
      D.19644 = &MEM[(void *)&header + 8B];
      D.19645 = *D.19644;
      if (D.19645 != 826364754) goto <D.19634>; else goto <D.19635>;
      <D.19634>:
      D.19544 = 0;
      return D.19544;
      <D.19635>:
      D.19646 = &MEM[(void *)&header + 12B];
      D.19647 = *D.19646;
      D.19648 = D.19647 >> 3;
      bitlen = (gint) D.19648;
      D.19649 = bitlen + 20;
      if (D.19649 != pkeylen) goto <D.19650>; else goto <D.19651>;
      <D.19650>:
      D.19544 = 0;
      return D.19544;
      <D.19651>:
      if (pubkey == 0B) goto <D.19652>; else goto <D.19653>;
      <D.19652>:
      D.19544 = 1;
      return D.19544;
      <D.19653>:
      offset = 0;
      if (keylen <= 127) goto <D.19654>; else goto <D.19655>;
      <D.19654>:
      D.19656 = keylen + 1;
      D.19657 = (unsigned int) D.19656;
      arr = monoeg_malloc (D.19657);
      offset.66 = offset;
      offset = offset.66 + 1;
      offset.67 = (sizetype) offset.66;
      D.19660 = arr + offset.67;
      D.19661 = (char) keylen;
      *D.19660 = D.19661;
      goto <D.19662>;
      <D.19655>:
      D.19663 = keylen + 2;
      D.19664 = (unsigned int) D.19663;
      arr = monoeg_malloc (D.19664);
      offset.68 = offset;
      offset = offset.68 + 1;
      offset.69 = (sizetype) offset.68;
      D.19667 = arr + offset.69;
      *D.19667 = -128;
      offset.70 = offset;
      offset = offset.70 + 1;
      offset.71 = (sizetype) offset.70;
      D.19670 = arr + offset.71;
      D.19661 = (char) keylen;
      *D.19670 = D.19661;
      <D.19662>:
      i = offset;
      j = 0;
      goto <D.17586>;
      <D.17585>:
      i.72 = (sizetype) i;
      D.19672 = arr + i.72;
      j.73 = j;
      j = j.73 + 1;
      j.74 = (sizetype) j.73;
      D.19675 = key + j.74;
      D.19676 = *D.19675;
      D.19677 = (int) D.19676;
      D.19678 = monoeg_g_ascii_xdigit_value (D.19677);
      D.19679 = D.19678 << 4;
      D.19680 = (char) D.19679;
      *D.19672 = D.19680;
      j.75 = j;
      j = j.75 + 1;
      j.76 = (sizetype) j.75;
      D.19683 = key + j.76;
      D.19684 = *D.19683;
      D.19685 = (int) D.19684;
      D.19686 = monoeg_g_ascii_xdigit_value (D.19685);
      i.72 = (sizetype) i;
      D.19672 = arr + i.72;
      i.72 = (sizetype) i;
      D.19672 = arr + i.72;
      D.19687 = *D.19672;
      D.19688 = (char) D.19686;
      D.19689 = D.19687 | D.19688;
      *D.19672 = D.19689;
      i = i + 1;
      <D.17586>:
      D.19690 = keylen + offset;
      if (D.19690 > i) goto <D.17585>; else goto <D.17587>;
      <D.17587>:
      *pubkey = arr;
      D.19544 = 1;
      return D.19544;
    }
  finally
    {
      header = {CLOBBER};
    }
}


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

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


mono_assembly_name_new (const char * name)
{
  int D.19695;
  struct MonoAssemblyName * D.19698;
  struct MonoAssemblyName * aname;

  aname = monoeg_malloc0 (60);
  D.19695 = mono_assembly_name_parse (name, aname);
  if (D.19695 != 0) goto <D.19696>; else goto <D.19697>;
  <D.19696>:
  D.19698 = aname;
  return D.19698;
  <D.19697>:
  monoeg_g_free (aname);
  D.19698 = 0B;
  return D.19698;
}


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

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


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

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


mono_assembly_name_get_pubkeytoken (struct MonoAssemblyName * aname)
{
  unsigned char D.19704;
  mono_byte * D.19707;

  D.19704 = aname->public_key_token[0];
  if (D.19704 != 0) goto <D.19705>; else goto <D.19706>;
  <D.19705>:
  D.19707 = &aname->public_key_token;
  return D.19707;
  <D.19706>:
  D.19707 = 0B;
  return D.19707;
}


mono_assembly_name_get_version (struct MonoAssemblyName * aname, uint16_t * minor, uint16_t * build, uint16_t * revision)
{
  short unsigned int D.19711;
  short unsigned int D.19714;
  short unsigned int D.19717;
  uint16_t D.19718;

  if (minor != 0B) goto <D.19709>; else goto <D.19710>;
  <D.19709>:
  D.19711 = aname->minor;
  *minor = D.19711;
  <D.19710>:
  if (build != 0B) goto <D.19712>; else goto <D.19713>;
  <D.19712>:
  D.19714 = aname->build;
  *build = D.19714;
  <D.19713>:
  if (revision != 0B) goto <D.19715>; else goto <D.19716>;
  <D.19715>:
  D.19717 = aname->revision;
  *revision = D.19717;
  <D.19716>:
  D.19718 = aname->major;
  return D.19718;
}


mono_assembly_load_with_partial_name (const char * name, MonoImageOpenStatus * status)
{
  int D.19720;
  struct MonoAssembly * D.19723;
  short unsigned int D.19724;
  short unsigned int D.19725;
  short unsigned int D.19726;
  short unsigned int D.19727;
  short unsigned int D.19728;
  short unsigned int D.19729;
  short unsigned int D.19730;
  char * * assemblies_path.77;
  const char * D.19738;
  char * * extra_gac_paths.78;
  gchar * D.19742;
  const char * D.19746;
  struct MonoString * D.19750;
  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.19720 = mono_assembly_name_parse (name, aname);
      if (D.19720 == 0) goto <D.19721>; else goto <D.19722>;
      <D.19721>:
      D.19723 = 0B;
      return D.19723;
      <D.19722>:
      D.19724 = aname->major;
      D.19725 = aname->minor;
      D.19726 = D.19724 | D.19725;
      D.19727 = aname->build;
      D.19728 = D.19726 | D.19727;
      D.19729 = aname->revision;
      D.19730 = D.19728 | D.19729;
      if (D.19730 == 0) goto <D.19731>; else goto <D.19732>;
      <D.19731>:
      aname = mono_assembly_remap_version (aname, &mapped_aname);
      <D.19732>:
      res = mono_assembly_loaded (aname);
      if (res != 0B) goto <D.19733>; else goto <D.19734>;
      <D.19733>:
      mono_assembly_name_free (aname);
      D.19723 = res;
      return D.19723;
      <D.19734>:
      assemblies_path.77 = assemblies_path;
      res = invoke_assembly_preload_hook (aname, assemblies_path.77);
      if (res != 0B) goto <D.19736>; else goto <D.19737>;
      <D.19736>:
      res->in_gac = 0;
      mono_assembly_name_free (aname);
      D.19723 = res;
      return D.19723;
      <D.19737>:
      D.19738 = aname->name;
      fullname = monoeg_g_strdup_printf ("%s.dll", D.19738);
      extra_gac_paths.78 = extra_gac_paths;
      if (extra_gac_paths.78 != 0B) goto <D.19740>; else goto <D.19741>;
      <D.19740>:
      paths = extra_gac_paths;
      goto <D.17737>;
      <D.17736>:
      D.19738 = aname->name;
      D.19742 = *paths;
      gacpath = monoeg_g_build_path ("/", D.19742, "lib", "mono", "gac", D.19738, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      paths = paths + 4;
      <D.17737>:
      if (res == 0B) goto <D.19743>; else goto <D.17738>;
      <D.19743>:
      D.19742 = *paths;
      if (D.19742 != 0B) goto <D.17736>; else goto <D.17738>;
      <D.17738>:
      <D.19741>:
      if (res != 0B) goto <D.19744>; else goto <D.19745>;
      <D.19744>:
      res->in_gac = 1;
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.19723 = res;
      return D.19723;
      <D.19745>:
      D.19738 = aname->name;
      D.19746 = mono_assembly_getrootdir ();
      gacpath = monoeg_g_build_path ("/", D.19746, "mono", "gac", D.19738, 0B);
      res = probe_for_partial_name (gacpath, fullname, aname, status);
      monoeg_g_free (gacpath);
      if (res != 0B) goto <D.19747>; else goto <D.19748>;
      <D.19747>:
      res->in_gac = 1;
      goto <D.19749>;
      <D.19748>:
      {
        struct MonoDomain * domain;
        struct MonoReflectionAssembly * refasm;

        domain = mono_domain_get ();
        D.19750 = mono_string_new (domain, name);
        refasm = mono_try_assembly_resolve (domain, D.19750, 0);
        if (refasm != 0B) goto <D.19751>; else goto <D.19752>;
        <D.19751>:
        res = refasm->assembly;
        <D.19752>:
      }
      <D.19749>:
      monoeg_g_free (fullname);
      mono_assembly_name_free (aname);
      D.19723 = res;
      return D.19723;
    }
  finally
    {
      base_name = {CLOBBER};
      mapped_aname = {CLOBBER};
    }
}


mono_assembly_remap_version (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_aname)
{
  const char * D.19755;
  struct MonoAssemblyName * D.19758;
  unsigned int D.19759;
  unsigned int D.19760;
  short unsigned int D.19763;
  short unsigned int D.19764;
  short unsigned int D.19765;
  short unsigned int D.19766;
  unsigned int D.19767;
  unsigned int D.19768;
  int D.17239;
  int iftmp.79;
  int D.17238;
  const char[11] * D.19772;
  unsigned char D.19773;
  int D.19774;
  unsigned char D.19775;
  int D.19776;
  _Bool D.19777;
  _Bool D.19778;
  _Bool D.19779;
  const unsigned char * D.19782;
  unsigned char D.19783;
  int D.19784;
  const unsigned char * D.19785;
  unsigned char D.19786;
  int D.19787;
  _Bool D.19788;
  _Bool D.19789;
  const unsigned char * D.19792;
  unsigned char D.19793;
  int D.19794;
  const unsigned char * D.19795;
  unsigned char D.19796;
  int D.19797;
  _Bool D.19798;
  _Bool D.19799;
  const unsigned char * D.19802;
  unsigned char D.19803;
  int D.19804;
  const unsigned char * D.19805;
  unsigned char D.19806;
  int D.19807;
  gchar * D.19811;
  int D.19812;
  int D.19813;
  int D.19814;
  int D.19815;
  const char * D.19816;
  short unsigned int D.19817;
  int D.19818;
  short unsigned int D.19819;
  int D.19820;
  short unsigned int D.19821;
  int D.19822;
  short unsigned int D.19823;
  int D.19824;
  int D.19825;
  int D.19826;
  int res.80;
  const char * D.19827;
  unsigned char D.19830;
  unsigned int index.81;
  _Bool D.19832;
  long int D.19833;
  long int D.19834;
  short unsigned int D.19837;
  short unsigned int D.19840;
  short unsigned int D.19843;
  short unsigned int D.19846;
  short unsigned int D.19849;
  short unsigned int D.19850;
  short unsigned int D.19851;
  int D.19854;
  int D.19855;
  int D.19856;
  int D.19857;
  const struct MonoRuntimeInfo * current_runtime;
  int pos;
  int first;
  int last;

  D.19755 = aname->name;
  if (D.19755 == 0B) goto <D.19756>; else goto <D.19757>;
  <D.19756>:
  D.19758 = aname;
  return D.19758;
  <D.19757>:
  current_runtime = mono_get_runtime_info ();
  D.19759 = aname->flags;
  D.19760 = D.19759 & 256;
  if (D.19760 != 0) goto <D.19761>; else goto <D.19762>;
  <D.19761>:
  {
    const struct AssemblyVersionSet * vset;

    vset = &current_runtime->version_sets[0];
    memcpy (dest_aname, aname, 60);
    D.19763 = vset->major;
    dest_aname->major = D.19763;
    D.19764 = vset->minor;
    dest_aname->minor = D.19764;
    D.19765 = vset->build;
    dest_aname->build = D.19765;
    D.19766 = vset->revision;
    dest_aname->revision = D.19766;
    D.19767 = dest_aname->flags;
    D.19768 = D.19767 & 4294967039;
    dest_aname->flags = D.19768;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = aname->name;
        D.19772 = "System.Net";
        D.19773 = MEM[(const unsigned char *)D.19772];
        D.19774 = (int) D.19773;
        D.19775 = *__s2;
        D.19776 = (int) D.19775;
        __result = D.19774 - D.19776;
        {
          D.19777 = __s2_len != 0;
          D.19778 = __result == 0;
          D.19779 = D.19777 & D.19778;
          if (D.19779 != 0) goto <D.19780>; else goto <D.19781>;
          <D.19780>:
          D.19782 = &MEM[(void *)"System.Net" + 1B];
          D.19783 = *D.19782;
          D.19784 = (int) D.19783;
          D.19785 = __s2 + 1;
          D.19786 = *D.19785;
          D.19787 = (int) D.19786;
          __result = D.19784 - D.19787;
          D.19788 = __s2_len > 1;
          D.19778 = __result == 0;
          D.19789 = D.19788 & D.19778;
          if (D.19789 != 0) goto <D.19790>; else goto <D.19791>;
          <D.19790>:
          D.19792 = &MEM[(void *)"System.Net" + 2B];
          D.19793 = *D.19792;
          D.19794 = (int) D.19793;
          D.19795 = __s2 + 2;
          D.19796 = *D.19795;
          D.19797 = (int) D.19796;
          __result = D.19794 - D.19797;
          D.19798 = __s2_len > 2;
          D.19778 = __result == 0;
          D.19799 = D.19798 & D.19778;
          if (D.19799 != 0) goto <D.19800>; else goto <D.19801>;
          <D.19800>:
          D.19802 = &MEM[(void *)"System.Net" + 3B];
          D.19803 = *D.19802;
          D.19804 = (int) D.19803;
          D.19805 = __s2 + 3;
          D.19806 = *D.19805;
          D.19807 = (int) D.19806;
          __result = D.19804 - D.19807;
          <D.19801>:
          <D.19791>:
          <D.19781>:
        }
        D.17238 = __result;
      }
      iftmp.79 = -D.17238;
      goto <D.19808>;
      <D.19771>:
      D.19755 = aname->name;
      iftmp.79 = __builtin_strcmp (D.19755, "System.Net");
      <D.19808>:
      D.17239 = iftmp.79;
    }
    if (D.17239 == 0) goto <D.19809>; else goto <D.19810>;
    <D.19809>:
    D.19811 = monoeg_strdup ("System");
    dest_aname->name = D.19811;
    <D.19810>:
    remap_keys (dest_aname);
    D.19766 = vset->revision;
    D.19812 = (int) D.19766;
    D.19765 = vset->build;
    D.19813 = (int) D.19765;
    D.19764 = vset->minor;
    D.19814 = (int) D.19764;
    D.19763 = vset->major;
    D.19815 = (int) D.19763;
    D.19816 = dest_aname->name;
    D.19817 = aname->revision;
    D.19818 = (int) D.19817;
    D.19819 = aname->build;
    D.19820 = (int) D.19819;
    D.19821 = aname->minor;
    D.19822 = (int) D.19821;
    D.19823 = aname->major;
    D.19824 = (int) D.19823;
    D.19755 = aname->name;
    mono_trace (64, 1, "The request to load the retargetable assembly %s v%d.%d.%d.%d was remapped to %s v%d.%d.%d.%d", D.19755, D.19824, D.19822, D.19820, D.19818, D.19816, D.19815, D.19814, D.19813, D.19812);
    D.19758 = dest_aname;
    return D.19758;
  }
  <D.19762>:
  first = 0;
  last = 62;
  goto <D.17253>;
  <D.17252>:
  {
    int res;

    D.19825 = last - first;
    D.19826 = D.19825 / 2;
    pos = D.19826 + first;
    {
      size_t __s1_len;
      size_t __s2_len;

      D.19827 = framework_assemblies[pos].assembly_name;
      D.19755 = aname->name;
      res.80 = __builtin_strcmp (D.19755, D.19827);
    }
    res = res.80;
    if (res == 0) goto <D.19828>; else goto <D.19829>;
    <D.19828>:
    {
      const struct AssemblyVersionSet * vset;
      int index;

      D.19830 = framework_assemblies[pos].version_set_index;
      index = (int) D.19830;
      index.81 = (unsigned int) index;
      D.19832 = index.81 > 3;
      D.19833 = (long int) D.19832;
      D.19834 = __builtin_expect (D.19833, 0);
      if (D.19834 != 0) goto <D.19835>; else goto <D.19836>;
      <D.19835>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 995, "index < G_N_ELEMENTS (current_runtime->version_sets)");
      <D.19836>:
      vset = &current_runtime->version_sets[index];
      D.19823 = aname->major;
      D.19837 = vset->major;
      if (D.19823 == D.19837) goto <D.19838>; else goto <D.19839>;
      <D.19838>:
      D.19821 = aname->minor;
      D.19840 = vset->minor;
      if (D.19821 == D.19840) goto <D.19841>; else goto <D.19842>;
      <D.19841>:
      D.19819 = aname->build;
      D.19843 = vset->build;
      if (D.19819 == D.19843) goto <D.19844>; else goto <D.19845>;
      <D.19844>:
      D.19817 = aname->revision;
      D.19846 = vset->revision;
      if (D.19817 == D.19846) goto <D.19847>; else goto <D.19848>;
      <D.19847>:
      D.19758 = aname;
      return D.19758;
      <D.19848>:
      <D.19845>:
      <D.19842>:
      <D.19839>:
      D.19823 = aname->major;
      D.19821 = aname->minor;
      D.19849 = D.19823 | D.19821;
      D.19819 = aname->build;
      D.19850 = D.19849 | D.19819;
      D.19817 = aname->revision;
      D.19851 = D.19850 | D.19817;
      if (D.19851 != 0) goto <D.19852>; else goto <D.19853>;
      <D.19852>:
      D.19846 = vset->revision;
      D.19854 = (int) D.19846;
      D.19843 = vset->build;
      D.19855 = (int) D.19843;
      D.19840 = vset->minor;
      D.19856 = (int) D.19840;
      D.19837 = vset->major;
      D.19857 = (int) D.19837;
      D.19817 = aname->revision;
      D.19818 = (int) D.19817;
      D.19819 = aname->build;
      D.19820 = (int) D.19819;
      D.19821 = aname->minor;
      D.19822 = (int) D.19821;
      D.19823 = aname->major;
      D.19824 = (int) D.19823;
      D.19755 = aname->name;
      mono_trace (16, 1, "The request to load the assembly %s v%d.%d.%d.%d was remapped to v%d.%d.%d.%d", D.19755, D.19824, D.19822, D.19820, D.19818, D.19857, D.19856, D.19855, D.19854);
      <D.19853>:
      memcpy (dest_aname, aname, 60);
      D.19837 = vset->major;
      dest_aname->major = D.19837;
      D.19840 = vset->minor;
      dest_aname->minor = D.19840;
      D.19843 = vset->build;
      dest_aname->build = D.19843;
      D.19846 = vset->revision;
      dest_aname->revision = D.19846;
      D.19758 = dest_aname;
      return D.19758;
    }
    <D.19829>:
    if (res < 0) goto <D.19858>; else goto <D.19859>;
    <D.19858>:
    last = pos + -1;
    goto <D.19860>;
    <D.19859>:
    first = pos + 1;
    <D.19860>:
  }
  <D.17253>:
  if (first <= last) goto <D.17252>; else goto <D.17254>;
  <D.17254>:
  D.19758 = aname;
  return D.19758;
}


remap_keys (struct MonoAssemblyName * aname)
{
  int D.17217;
  const char * D.19864;
  const char * D.19865;
  const char * D.19867;
  mono_byte[17] * D.19868;
  int D.19869;
  const char * D.19870;
  unsigned int i.82;
  int i;

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

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

      D.19864 = entry->name;
      D.19865 = aname->name;
      D.17217 = __builtin_strcmp (D.19865, D.19864);
    }
    if (D.17217 != 0) goto <D.19862>; else goto <D.19866>;
    <D.19866>:
    D.19867 = entry->from;
    D.19868 = &aname->public_key_token;
    D.19869 = mono_public_tokens_are_equal (D.19868, D.19867);
    if (D.19869 == 0) goto <D.19862>; else goto <D.19863>;
    <D.19862>:
    // predicted unlikely by continue predictor.
    goto <D.17218>;
    <D.19863>:
    D.19870 = entry->to;
    D.19868 = &aname->public_key_token;
    memcpy (D.19868, D.19870, 17);
    D.19870 = entry->to;
    D.19867 = entry->from;
    D.19865 = aname->name;
    mono_trace (64, 1, "Remapped public key token of retargetable assembly %s from %s to %s", D.19865, D.19867, D.19870);
    return;
  }
  <D.17218>:
  i = i + 1;
  <D.17220>:
  i.82 = (unsigned int) i;
  if (i.82 <= 13) goto <D.17219>; else goto <D.17221>;
  <D.17221>:
}


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

  D.19874 = __builtin_object_size (__dest, 0);
  D.19873 = __builtin___memcpy_chk (__dest, __src, __len, D.19874);
  return D.19873;
}


invoke_assembly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<Te89>) (struct MonoAssemblyName *, char * *, void *) D.19876;
  void * D.19877;
  struct MonoAssembly * D.19880;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_preload_hook;
  goto <D.17382>;
  <D.17381>:
  D.19876 = hook->func;
  D.19877 = hook->user_data;
  assembly = D.19876 (aname, assemblies_path, D.19877);
  if (assembly != 0B) goto <D.19878>; else goto <D.19879>;
  <D.19878>:
  D.19880 = assembly;
  return D.19880;
  <D.19879>:
  hook = hook->next;
  <D.17382>:
  if (hook != 0B) goto <D.17381>; else goto <D.17383>;
  <D.17383>:
  D.19880 = 0B;
  return D.19880;
}


probe_for_partial_name (const char * basepath, const char * fullname, struct MonoAssemblyName * aname, MonoImageOpenStatus * status)
{
  struct MonoAssembly * D.19884;
  short unsigned int D.19885;
  short unsigned int D.19886;
  short unsigned int D.19887;
  short unsigned int D.19888;
  short unsigned int D.19889;
  short unsigned int D.19890;
  short unsigned int D.19891;
  _Bool D.19892;
  const char * D.19893;
  int D.19894;
  const char * D.19897;
  int D.17721;
  const char * D.19900;
  mono_byte[17] * D.19905;
  char D.19906;
  int D.19909;
  int iftmp.83;
  unsigned int D.19919;
  unsigned int D.19920;
  unsigned int D.19921;
  unsigned int D.19922;
  unsigned int D.19924;
  unsigned int D.19925;
  unsigned int D.19926;
  unsigned int D.19927;
  short unsigned int D.19930;
  int D.19931;
  short unsigned int D.19937;
  int D.19938;
  short unsigned int D.19944;
  int D.19945;
  short unsigned int D.19951;
  int D.19952;
  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.19882>; else goto <D.19883>;
      <D.19882>:
      D.19884 = 0B;
      return D.19884;
      <D.19883>:
      D.19885 = aname->major;
      D.19886 = aname->minor;
      D.19887 = D.19885 | D.19886;
      D.19888 = aname->build;
      D.19889 = D.19887 | D.19888;
      D.19890 = aname->revision;
      D.19891 = D.19889 | D.19890;
      D.19892 = D.19891 != 0;
      exact_version = (gboolean) D.19892;
      goto <D.17712>;
      <D.17722>:
      {
        gboolean match;

        match = 1;
        D.19893 = aname->name;
        D.19894 = parse_assembly_directory_name (D.19893, direntry, &gac_aname);
        if (D.19894 == 0) goto <D.19895>; else goto <D.19896>;
        <D.19895>:
        // predicted unlikely by continue predictor.
        goto <D.17712>;
        <D.19896>:
        D.19897 = aname->culture;
        if (D.19897 != 0B) goto <D.19898>; else goto <D.19899>;
        <D.19898>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.19900 = gac_aname.culture;
          D.19897 = aname->culture;
          D.17721 = __builtin_strcmp (D.19897, D.19900);
        }
        if (D.17721 != 0) goto <D.19901>; else goto <D.19902>;
        <D.19901>:
        match = 0;
        <D.19902>:
        <D.19899>:
        if (match != 0) goto <D.19903>; else goto <D.19904>;
        <D.19903>:
        D.19905 = &aname->public_key_token;
        D.19906 = MEM[(const char *)D.19905];
        if (D.19906 != 0) goto <D.19907>; else goto <D.19908>;
        <D.19907>:
        D.19905 = &aname->public_key_token;
        D.19909 = mono_public_tokens_are_equal (D.19905, &gac_aname.public_key_token);
        if (D.19909 == 0) goto <D.19910>; else goto <D.19911>;
        <D.19910>:
        match = 0;
        <D.19911>:
        <D.19908>:
        <D.19904>:
        if (match != 0) goto <D.19912>; else goto <D.19913>;
        <D.19912>:
        if (exact_version != 0) goto <D.19914>; else goto <D.19915>;
        <D.19914>:
        D.19919 = BIT_FIELD_REF <*aname, 32, 384>;
        D.19920 = D.19919;
        D.19921 = BIT_FIELD_REF <gac_aname, 32, 384>;
        D.19922 = D.19921;
        if (D.19920 == D.19922) goto <D.19923>; else goto <D.19917>;
        <D.19923>:
        D.19924 = BIT_FIELD_REF <*aname, 32, 416>;
        D.19925 = D.19924;
        D.19926 = BIT_FIELD_REF <gac_aname, 32, 416>;
        D.19927 = D.19926;
        if (D.19925 == D.19927) goto <D.19928>; else goto <D.19917>;
        <D.19928>:
        iftmp.83 = 1;
        goto <D.19918>;
        <D.19917>:
        iftmp.83 = 0;
        <D.19918>:
        match = iftmp.83;
        goto <D.19929>;
        <D.19915>:
        D.19930 = gac_aname.major;
        D.19931 = (int) D.19930;
        if (D.19931 < major) goto <D.19932>; else goto <D.19933>;
        <D.19932>:
        match = 0;
        goto <D.19934>;
        <D.19933>:
        D.19930 = gac_aname.major;
        D.19931 = (int) D.19930;
        if (D.19931 == major) goto <D.19935>; else goto <D.19936>;
        <D.19935>:
        D.19937 = gac_aname.minor;
        D.19938 = (int) D.19937;
        if (D.19938 < minor) goto <D.19939>; else goto <D.19940>;
        <D.19939>:
        match = 0;
        goto <D.19941>;
        <D.19940>:
        D.19937 = gac_aname.minor;
        D.19938 = (int) D.19937;
        if (D.19938 == minor) goto <D.19942>; else goto <D.19943>;
        <D.19942>:
        D.19944 = gac_aname.build;
        D.19945 = (int) D.19944;
        if (D.19945 < build) goto <D.19946>; else goto <D.19947>;
        <D.19946>:
        match = 0;
        goto <D.19948>;
        <D.19947>:
        D.19944 = gac_aname.build;
        D.19945 = (int) D.19944;
        if (D.19945 == build) goto <D.19949>; else goto <D.19950>;
        <D.19949>:
        D.19951 = gac_aname.revision;
        D.19952 = (int) D.19951;
        if (D.19952 <= revision) goto <D.19953>; else goto <D.19954>;
        <D.19953>:
        match = 0;
        <D.19954>:
        <D.19950>:
        <D.19948>:
        <D.19943>:
        <D.19941>:
        <D.19936>:
        <D.19934>:
        <D.19929>:
        <D.19913>:
        if (match != 0) goto <D.19955>; else goto <D.19956>;
        <D.19955>:
        D.19930 = gac_aname.major;
        major = (gint) D.19930;
        D.19937 = gac_aname.minor;
        minor = (gint) D.19937;
        D.19944 = gac_aname.build;
        build = (gint) D.19944;
        D.19951 = gac_aname.revision;
        revision = (gint) D.19951;
        monoeg_g_free (fullpath);
        fullpath = monoeg_g_build_path ("/", basepath, direntry, fullname, 0B);
        <D.19956>:
        mono_assembly_name_free (&gac_aname);
      }
      <D.17712>:
      direntry = monoeg_g_dir_read_name (dirhandle);
      if (direntry != 0B) goto <D.17722>; else goto <D.17723>;
      <D.17723>:
      monoeg_g_dir_close (dirhandle);
      if (fullpath == 0B) goto <D.19957>; else goto <D.19958>;
      <D.19957>:
      D.19884 = 0B;
      return D.19884;
      <D.19958>:
      {
        struct MonoAssembly * res;

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


parse_assembly_directory_name (const char * name, const char * dirname, struct MonoAssemblyName * aname)
{
  gchar * D.19964;
  gchar * * D.19966;
  gchar * D.19967;
  gchar * * D.19969;
  gchar * D.19970;
  gboolean D.19971;
  gchar * * parts;
  gboolean res;

  parts = monoeg_g_strsplit (dirname, "_", 3);
  if (parts == 0B) goto <D.19961>; else goto <D.19963>;
  <D.19963>:
  D.19964 = *parts;
  if (D.19964 == 0B) goto <D.19961>; else goto <D.19965>;
  <D.19965>:
  D.19966 = parts + 4;
  D.19967 = *D.19966;
  if (D.19967 == 0B) goto <D.19961>; else goto <D.19968>;
  <D.19968>:
  D.19969 = parts + 8;
  D.19970 = *D.19969;
  if (D.19970 == 0B) goto <D.19961>; else goto <D.19962>;
  <D.19961>:
  monoeg_g_strfreev (parts);
  D.19971 = 0;
  return D.19971;
  <D.19962>:
  D.19969 = parts + 8;
  D.19970 = *D.19969;
  D.19966 = parts + 4;
  D.19967 = *D.19966;
  D.19964 = *parts;
  res = build_assembly_name (name, D.19964, D.19967, D.19970, 0B, 0, 0, aname, 0);
  monoeg_g_strfreev (parts);
  D.19971 = res;
  return D.19971;
}


mono_assembly_load_corlib (const struct MonoRuntimeInfo * runtime, MonoImageOpenStatus * status)
{
  struct MonoAssembly * corlib.84;
  struct MonoAssembly * D.19976;
  char * * assemblies_path.85;
  struct MonoAssembly * corlib.86;
  struct MonoAssembly * corlib.87;
  const char[4] * D.19986;
  struct MonoAssembly * corlib.88;
  struct MonoAssembly * corlib.89;
  int D.17926;
  int iftmp.90;
  int D.17925;
  const char[4] * D.19998;
  unsigned char D.19999;
  int D.20000;
  unsigned char D.20001;
  int D.20002;
  _Bool D.20003;
  _Bool D.20004;
  _Bool D.20005;
  const unsigned char * D.20008;
  unsigned char D.20009;
  int D.20010;
  const unsigned char * D.20011;
  unsigned char D.20012;
  int D.20013;
  _Bool D.20014;
  _Bool D.20015;
  const unsigned char * D.20018;
  unsigned char D.20019;
  int D.20020;
  const unsigned char * D.20021;
  unsigned char D.20022;
  int D.20023;
  _Bool D.20024;
  _Bool D.20025;
  const unsigned char * D.20028;
  unsigned char D.20029;
  int D.20030;
  const unsigned char * D.20031;
  unsigned char D.20032;
  int D.20033;
  const char * D.20037;
  gchar * D.20038;
  char * corlib_file;
  struct MonoAssemblyName * aname;

  corlib.84 = corlib;
  if (corlib.84 != 0B) goto <D.19974>; else goto <D.19975>;
  <D.19974>:
  D.19976 = corlib;
  return D.19976;
  <D.19975>:
  aname = mono_assembly_name_new ("mscorlib.dll");
  assemblies_path.85 = assemblies_path;
  corlib.86 = invoke_assembly_preload_hook (aname, assemblies_path.85);
  corlib = corlib.86;
  mono_assembly_name_free (aname);
  monoeg_g_free (aname);
  corlib.84 = corlib;
  if (corlib.84 != 0B) goto <D.19979>; else goto <D.19980>;
  <D.19979>:
  D.19976 = corlib;
  return D.19976;
  <D.19980>:
  assemblies_path.85 = assemblies_path;
  if (assemblies_path.85 != 0B) goto <D.19981>; else goto <D.19982>;
  <D.19981>:
  assemblies_path.85 = assemblies_path;
  corlib.87 = load_in_path ("mscorlib.dll", assemblies_path.85, status, 0);
  corlib = corlib.87;
  corlib.84 = corlib;
  if (corlib.84 != 0B) goto <D.19984>; else goto <D.19985>;
  <D.19984>:
  D.19976 = corlib;
  return D.19976;
  <D.19985>:
  <D.19982>:
  D.19986 = &runtime->framework_version;
  corlib_file = monoeg_g_build_path ("/", "mono", D.19986, "mscorlib.dll", 0B);
  assemblies_path.85 = assemblies_path;
  if (assemblies_path.85 != 0B) goto <D.19987>; else goto <D.19988>;
  <D.19987>:
  assemblies_path.85 = assemblies_path;
  corlib.88 = load_in_path (corlib_file, assemblies_path.85, status, 0);
  corlib = corlib.88;
  corlib.84 = corlib;
  if (corlib.84 != 0B) goto <D.19990>; else goto <D.19991>;
  <D.19990>:
  monoeg_g_free (corlib_file);
  D.19976 = corlib;
  return D.19976;
  <D.19991>:
  <D.19988>:
  corlib.89 = load_in_path (corlib_file, &default_path, status, 0);
  corlib = corlib.89;
  monoeg_g_free (corlib_file);
  corlib.84 = corlib;
  if (corlib.84 != 0B) goto <D.19993>; else goto <D.19994>;
  <D.19993>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = &runtime->framework_version;
      D.19998 = "4.5";
      D.19999 = MEM[(const unsigned char *)D.19998];
      D.20000 = (int) D.19999;
      D.20001 = *__s2;
      D.20002 = (int) D.20001;
      __result = D.20000 - D.20002;
      {
        D.20003 = __s2_len != 0;
        D.20004 = __result == 0;
        D.20005 = D.20003 & D.20004;
        if (D.20005 != 0) goto <D.20006>; else goto <D.20007>;
        <D.20006>:
        D.20008 = &MEM[(void *)"4.5" + 1B];
        D.20009 = *D.20008;
        D.20010 = (int) D.20009;
        D.20011 = __s2 + 1;
        D.20012 = *D.20011;
        D.20013 = (int) D.20012;
        __result = D.20010 - D.20013;
        D.20014 = __s2_len > 1;
        D.20004 = __result == 0;
        D.20015 = D.20014 & D.20004;
        if (D.20015 != 0) goto <D.20016>; else goto <D.20017>;
        <D.20016>:
        D.20018 = &MEM[(void *)"4.5" + 2B];
        D.20019 = *D.20018;
        D.20020 = (int) D.20019;
        D.20021 = __s2 + 2;
        D.20022 = *D.20021;
        D.20023 = (int) D.20022;
        __result = D.20020 - D.20023;
        D.20024 = __s2_len > 2;
        D.20004 = __result == 0;
        D.20025 = D.20024 & D.20004;
        if (D.20025 != 0) goto <D.20026>; else goto <D.20027>;
        <D.20026>:
        D.20028 = &MEM[(void *)"4.5" + 3B];
        D.20029 = *D.20028;
        D.20030 = (int) D.20029;
        D.20031 = __s2 + 3;
        D.20032 = *D.20031;
        D.20033 = (int) D.20032;
        __result = D.20030 - D.20033;
        <D.20027>:
        <D.20017>:
        <D.20007>:
      }
      D.17925 = __result;
    }
    iftmp.90 = -D.17925;
    goto <D.20034>;
    <D.19997>:
    D.19986 = &runtime->framework_version;
    iftmp.90 = __builtin_strcmp (D.19986, "4.5");
    <D.20034>:
    D.17926 = iftmp.90;
  }
  if (D.17926 == 0) goto <D.20035>; else goto <D.20036>;
  <D.20035>:
  D.20037 = default_path[0];
  D.20038 = monoeg_g_strdup_printf ("%s/mono/4.5/Facades", D.20037);
  default_path[1] = D.20038;
  <D.20036>:
  <D.19994>:
  D.19976 = corlib;
  return D.19976;
}


load_in_path (const char * basename, const char * * search_path, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  unsigned int i.91;
  unsigned int D.20041;
  const char * * D.20042;
  const char * D.20043;
  int D.20044;
  struct MonoAssembly * D.20047;
  int i;
  char * fullpath;
  struct MonoAssembly * result;

  i = 0;
  goto <D.17051>;
  <D.17050>:
  i.91 = (unsigned int) i;
  D.20041 = i.91 * 4;
  D.20042 = search_path + D.20041;
  D.20043 = *D.20042;
  fullpath = monoeg_g_build_path ("/", D.20043, basename, 0B);
  D.20044 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.20044);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.20045>; else goto <D.20046>;
  <D.20045>:
  D.20047 = result;
  return D.20047;
  <D.20046>:
  i = i + 1;
  <D.17051>:
  i.91 = (unsigned int) i;
  D.20041 = i.91 * 4;
  D.20042 = search_path + D.20041;
  D.20043 = *D.20042;
  if (D.20043 != 0B) goto <D.17050>; else goto <D.17052>;
  <D.17052>:
  D.20047 = 0B;
  return D.20047;
}


mono_assembly_load_full_nosearch (struct MonoAssemblyName * aname, const char * basedir, MonoImageOpenStatus * status, gboolean refonly)
{
  struct MonoAssembly * D.20053;
  struct MonoAssembly * iftmp.92;
  char * * assemblies_path.93;
  int D.17949;
  int iftmp.94;
  int D.17948;
  const char[9] * D.20066;
  unsigned char D.20067;
  int D.20068;
  unsigned char D.20069;
  int D.20070;
  _Bool D.20071;
  _Bool D.20072;
  _Bool D.20073;
  const unsigned char * D.20076;
  unsigned char D.20077;
  int D.20078;
  const unsigned char * D.20079;
  unsigned char D.20080;
  int D.20081;
  _Bool D.20082;
  _Bool D.20083;
  const unsigned char * D.20086;
  unsigned char D.20087;
  int D.20088;
  const unsigned char * D.20089;
  unsigned char D.20090;
  int D.20091;
  _Bool D.20092;
  _Bool D.20093;
  const unsigned char * D.20096;
  unsigned char D.20097;
  int D.20098;
  const unsigned char * D.20099;
  unsigned char D.20100;
  int D.20101;
  const char * D.20103;
  int D.17958;
  int iftmp.95;
  int D.17957;
  const char[13] * D.20108;
  unsigned char D.20109;
  int D.20110;
  unsigned char D.20111;
  int D.20112;
  _Bool D.20113;
  _Bool D.20114;
  _Bool D.20115;
  const unsigned char * D.20118;
  unsigned char D.20119;
  int D.20120;
  const unsigned char * D.20121;
  unsigned char D.20122;
  int D.20123;
  _Bool D.20124;
  _Bool D.20125;
  const unsigned char * D.20128;
  unsigned char D.20129;
  int D.20130;
  const unsigned char * D.20131;
  unsigned char D.20132;
  int D.20133;
  _Bool D.20134;
  _Bool D.20135;
  const unsigned char * D.20138;
  unsigned char D.20139;
  int D.20140;
  const unsigned char * D.20141;
  unsigned char D.20142;
  int D.20143;
  const struct MonoRuntimeInfo * D.20145;
  unsigned int D.20146;
  const char * iftmp.96;
  int D.17967;
  int iftmp.97;
  int D.17966;
  sizetype len.98;
  sizetype D.20159;
  const char[5] * D.20160;
  unsigned char D.20161;
  int D.20162;
  unsigned char D.20163;
  int D.20164;
  _Bool D.20165;
  _Bool D.20166;
  _Bool D.20167;
  const unsigned char * D.20170;
  unsigned char D.20171;
  int D.20172;
  const unsigned char * D.20173;
  unsigned char D.20174;
  int D.20175;
  _Bool D.20176;
  _Bool D.20177;
  const unsigned char * D.20180;
  unsigned char D.20181;
  int D.20182;
  const unsigned char * D.20183;
  unsigned char D.20184;
  int D.20185;
  _Bool D.20186;
  _Bool D.20187;
  const unsigned char * D.20190;
  unsigned char D.20191;
  int D.20192;
  const unsigned char * D.20193;
  unsigned char D.20194;
  int D.20195;
  const char * D.20197;
  int D.17976;
  int iftmp.99;
  int D.17975;
  const char[5] * D.20202;
  unsigned char D.20203;
  int D.20204;
  unsigned char D.20205;
  int D.20206;
  _Bool D.20207;
  _Bool D.20208;
  _Bool D.20209;
  const unsigned char * D.20212;
  unsigned char D.20213;
  int D.20214;
  const unsigned char * D.20215;
  unsigned char D.20216;
  int D.20217;
  _Bool D.20218;
  _Bool D.20219;
  const unsigned char * D.20222;
  unsigned char D.20223;
  int D.20224;
  const unsigned char * D.20225;
  unsigned char D.20226;
  int D.20227;
  _Bool D.20228;
  _Bool D.20229;
  const unsigned char * D.20232;
  unsigned char D.20233;
  int D.20234;
  const unsigned char * D.20235;
  unsigned char D.20236;
  int D.20237;
  unsigned char D.20239;
  int D.20240;
  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.20049>; else goto <D.20050>;
      <D.20049>:
      aname = mono_assembly_apply_binding (aname, &maped_name_pp);
      <D.20050>:
      result = mono_assembly_loaded_full (aname, refonly);
      if (result != 0B) goto <D.20051>; else goto <D.20052>;
      <D.20051>:
      D.20053 = result;
      return D.20053;
      <D.20052>:
      if (refonly != 0) goto <D.20055>; else goto <D.20056>;
      <D.20055>:
      assemblies_path.93 = assemblies_path;
      iftmp.92 = invoke_assembly_refonly_preload_hook (aname, assemblies_path.93);
      goto <D.20058>;
      <D.20056>:
      assemblies_path.93 = assemblies_path;
      iftmp.92 = invoke_assembly_preload_hook (aname, assemblies_path.93);
      <D.20058>:
      result = iftmp.92;
      if (result != 0B) goto <D.20059>; else goto <D.20060>;
      <D.20059>:
      result->in_gac = 0;
      D.20053 = result;
      return D.20053;
      <D.20060>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = aname->name;
          D.20066 = "mscorlib";
          D.20067 = MEM[(const unsigned char *)D.20066];
          D.20068 = (int) D.20067;
          D.20069 = *__s2;
          D.20070 = (int) D.20069;
          __result = D.20068 - D.20070;
          {
            D.20071 = __s2_len != 0;
            D.20072 = __result == 0;
            D.20073 = D.20071 & D.20072;
            if (D.20073 != 0) goto <D.20074>; else goto <D.20075>;
            <D.20074>:
            D.20076 = &MEM[(void *)"mscorlib" + 1B];
            D.20077 = *D.20076;
            D.20078 = (int) D.20077;
            D.20079 = __s2 + 1;
            D.20080 = *D.20079;
            D.20081 = (int) D.20080;
            __result = D.20078 - D.20081;
            D.20082 = __s2_len > 1;
            D.20072 = __result == 0;
            D.20083 = D.20082 & D.20072;
            if (D.20083 != 0) goto <D.20084>; else goto <D.20085>;
            <D.20084>:
            D.20086 = &MEM[(void *)"mscorlib" + 2B];
            D.20087 = *D.20086;
            D.20088 = (int) D.20087;
            D.20089 = __s2 + 2;
            D.20090 = *D.20089;
            D.20091 = (int) D.20090;
            __result = D.20088 - D.20091;
            D.20092 = __s2_len > 2;
            D.20072 = __result == 0;
            D.20093 = D.20092 & D.20072;
            if (D.20093 != 0) goto <D.20094>; else goto <D.20095>;
            <D.20094>:
            D.20096 = &MEM[(void *)"mscorlib" + 3B];
            D.20097 = *D.20096;
            D.20098 = (int) D.20097;
            D.20099 = __s2 + 3;
            D.20100 = *D.20099;
            D.20101 = (int) D.20100;
            __result = D.20098 - D.20101;
            <D.20095>:
            <D.20085>:
            <D.20075>:
          }
          D.17948 = __result;
        }
        iftmp.94 = -D.17948;
        goto <D.20102>;
        <D.20065>:
        D.20103 = aname->name;
        iftmp.94 = __builtin_strcmp (D.20103, "mscorlib");
        <D.20102>:
        D.17949 = iftmp.94;
      }
      if (D.17949 == 0) goto <D.20061>; else goto <D.20104>;
      <D.20104>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = aname->name;
          D.20108 = "mscorlib.dll";
          D.20109 = MEM[(const unsigned char *)D.20108];
          D.20110 = (int) D.20109;
          D.20111 = *__s2;
          D.20112 = (int) D.20111;
          __result = D.20110 - D.20112;
          {
            D.20113 = __s2_len != 0;
            D.20114 = __result == 0;
            D.20115 = D.20113 & D.20114;
            if (D.20115 != 0) goto <D.20116>; else goto <D.20117>;
            <D.20116>:
            D.20118 = &MEM[(void *)"mscorlib.dll" + 1B];
            D.20119 = *D.20118;
            D.20120 = (int) D.20119;
            D.20121 = __s2 + 1;
            D.20122 = *D.20121;
            D.20123 = (int) D.20122;
            __result = D.20120 - D.20123;
            D.20124 = __s2_len > 1;
            D.20114 = __result == 0;
            D.20125 = D.20124 & D.20114;
            if (D.20125 != 0) goto <D.20126>; else goto <D.20127>;
            <D.20126>:
            D.20128 = &MEM[(void *)"mscorlib.dll" + 2B];
            D.20129 = *D.20128;
            D.20130 = (int) D.20129;
            D.20131 = __s2 + 2;
            D.20132 = *D.20131;
            D.20133 = (int) D.20132;
            __result = D.20130 - D.20133;
            D.20134 = __s2_len > 2;
            D.20114 = __result == 0;
            D.20135 = D.20134 & D.20114;
            if (D.20135 != 0) goto <D.20136>; else goto <D.20137>;
            <D.20136>:
            D.20138 = &MEM[(void *)"mscorlib.dll" + 3B];
            D.20139 = *D.20138;
            D.20140 = (int) D.20139;
            D.20141 = __s2 + 3;
            D.20142 = *D.20141;
            D.20143 = (int) D.20142;
            __result = D.20140 - D.20143;
            <D.20137>:
            <D.20127>:
            <D.20117>:
          }
          D.17957 = __result;
        }
        iftmp.95 = -D.17957;
        goto <D.20144>;
        <D.20107>:
        D.20103 = aname->name;
        iftmp.95 = __builtin_strcmp (D.20103, "mscorlib.dll");
        <D.20144>:
        D.17958 = iftmp.95;
      }
      if (D.17958 == 0) goto <D.20061>; else goto <D.20062>;
      <D.20061>:
      D.20145 = mono_get_runtime_info ();
      D.20053 = mono_assembly_load_corlib (D.20145, status);
      return D.20053;
      <D.20062>:
      D.20103 = aname->name;
      D.20146 = strlen (D.20103);
      len = (int) D.20146;
      ext_index = 0;
      goto <D.17978>;
      <D.17977>:
      if (ext_index == 0) goto <D.20148>; else goto <D.20149>;
      <D.20148>:
      iftmp.96 = ".dll";
      goto <D.20150>;
      <D.20149>:
      iftmp.96 = ".exe";
      <D.20150>:
      ext = iftmp.96;
      if (len > 4) goto <D.20154>; else goto <D.20151>;
      <D.20154>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.20103 = aname->name;
          len.98 = (sizetype) len;
          D.20159 = len.98 + 4294967292;
          __s2 = D.20103 + D.20159;
          D.20160 = ".dll";
          D.20161 = MEM[(const unsigned char *)D.20160];
          D.20162 = (int) D.20161;
          D.20163 = *__s2;
          D.20164 = (int) D.20163;
          __result = D.20162 - D.20164;
          {
            D.20165 = __s2_len != 0;
            D.20166 = __result == 0;
            D.20167 = D.20165 & D.20166;
            if (D.20167 != 0) goto <D.20168>; else goto <D.20169>;
            <D.20168>:
            D.20170 = &MEM[(void *)".dll" + 1B];
            D.20171 = *D.20170;
            D.20172 = (int) D.20171;
            D.20173 = __s2 + 1;
            D.20174 = *D.20173;
            D.20175 = (int) D.20174;
            __result = D.20172 - D.20175;
            D.20176 = __s2_len > 1;
            D.20166 = __result == 0;
            D.20177 = D.20176 & D.20166;
            if (D.20177 != 0) goto <D.20178>; else goto <D.20179>;
            <D.20178>:
            D.20180 = &MEM[(void *)".dll" + 2B];
            D.20181 = *D.20180;
            D.20182 = (int) D.20181;
            D.20183 = __s2 + 2;
            D.20184 = *D.20183;
            D.20185 = (int) D.20184;
            __result = D.20182 - D.20185;
            D.20186 = __s2_len > 2;
            D.20166 = __result == 0;
            D.20187 = D.20186 & D.20166;
            if (D.20187 != 0) goto <D.20188>; else goto <D.20189>;
            <D.20188>:
            D.20190 = &MEM[(void *)".dll" + 3B];
            D.20191 = *D.20190;
            D.20192 = (int) D.20191;
            D.20193 = __s2 + 3;
            D.20194 = *D.20193;
            D.20195 = (int) D.20194;
            __result = D.20192 - D.20195;
            <D.20189>:
            <D.20179>:
            <D.20169>:
          }
          D.17966 = __result;
        }
        iftmp.97 = -D.17966;
        goto <D.20196>;
        <D.20157>:
        D.20103 = aname->name;
        len.98 = (sizetype) len;
        D.20159 = len.98 + 4294967292;
        D.20197 = D.20103 + D.20159;
        iftmp.97 = __builtin_strcmp (D.20197, ".dll");
        <D.20196>:
        D.17967 = iftmp.97;
      }
      if (D.17967 == 0) goto <D.20152>; else goto <D.20198>;
      <D.20198>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.20103 = aname->name;
          len.98 = (sizetype) len;
          D.20159 = len.98 + 4294967292;
          __s2 = D.20103 + D.20159;
          D.20202 = ".exe";
          D.20203 = MEM[(const unsigned char *)D.20202];
          D.20204 = (int) D.20203;
          D.20205 = *__s2;
          D.20206 = (int) D.20205;
          __result = D.20204 - D.20206;
          {
            D.20207 = __s2_len != 0;
            D.20208 = __result == 0;
            D.20209 = D.20207 & D.20208;
            if (D.20209 != 0) goto <D.20210>; else goto <D.20211>;
            <D.20210>:
            D.20212 = &MEM[(void *)".exe" + 1B];
            D.20213 = *D.20212;
            D.20214 = (int) D.20213;
            D.20215 = __s2 + 1;
            D.20216 = *D.20215;
            D.20217 = (int) D.20216;
            __result = D.20214 - D.20217;
            D.20218 = __s2_len > 1;
            D.20208 = __result == 0;
            D.20219 = D.20218 & D.20208;
            if (D.20219 != 0) goto <D.20220>; else goto <D.20221>;
            <D.20220>:
            D.20222 = &MEM[(void *)".exe" + 2B];
            D.20223 = *D.20222;
            D.20224 = (int) D.20223;
            D.20225 = __s2 + 2;
            D.20226 = *D.20225;
            D.20227 = (int) D.20226;
            __result = D.20224 - D.20227;
            D.20228 = __s2_len > 2;
            D.20208 = __result == 0;
            D.20229 = D.20228 & D.20208;
            if (D.20229 != 0) goto <D.20230>; else goto <D.20231>;
            <D.20230>:
            D.20232 = &MEM[(void *)".exe" + 3B];
            D.20233 = *D.20232;
            D.20234 = (int) D.20233;
            D.20235 = __s2 + 3;
            D.20236 = *D.20235;
            D.20237 = (int) D.20236;
            __result = D.20234 - D.20237;
            <D.20231>:
            <D.20221>:
            <D.20211>:
          }
          D.17975 = __result;
        }
        iftmp.99 = -D.17975;
        goto <D.20238>;
        <D.20201>:
        D.20103 = aname->name;
        len.98 = (sizetype) len;
        D.20159 = len.98 + 4294967292;
        D.20197 = D.20103 + D.20159;
        iftmp.99 = __builtin_strcmp (D.20197, ".exe");
        <D.20238>:
        D.17976 = iftmp.99;
      }
      if (D.17976 == 0) goto <D.20152>; else goto <D.20151>;
      <D.20152>:
      D.20103 = aname->name;
      filename = monoeg_strdup (D.20103);
      ext_index = ext_index + 1;
      goto <D.20153>;
      <D.20151>:
      D.20103 = aname->name;
      filename = monoeg_g_strconcat (D.20103, ext, 0B);
      <D.20153>:
      D.20239 = (unsigned char) refonly;
      D.20240 = (int) D.20239;
      result = mono_assembly_load_from_gac (aname, filename, status, D.20240);
      if (result != 0B) goto <D.20241>; else goto <D.20242>;
      <D.20241>:
      monoeg_g_free (filename);
      D.20053 = result;
      return D.20053;
      <D.20242>:
      if (basedir != 0B) goto <D.20243>; else goto <D.20244>;
      <D.20243>:
      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.20245>; else goto <D.20246>;
      <D.20245>:
      result->in_gac = 0;
      monoeg_g_free (filename);
      D.20053 = result;
      return D.20053;
      <D.20246>:
      <D.20244>:
      D.20239 = (unsigned char) refonly;
      D.20240 = (int) D.20239;
      result = load_in_path (filename, &default_path, status, D.20240);
      if (result != 0B) goto <D.20247>; else goto <D.20248>;
      <D.20247>:
      result->in_gac = 0;
      <D.20248>:
      monoeg_g_free (filename);
      if (result != 0B) goto <D.20249>; else goto <D.20250>;
      <D.20249>:
      D.20053 = result;
      return D.20053;
      <D.20250>:
      ext_index = ext_index + 1;
      <D.17978>:
      if (ext_index <= 1) goto <D.17977>; else goto <D.17979>;
      <D.17979>:
      D.20053 = result;
      return D.20053;
    }
  finally
    {
      maped_aname = {CLOBBER};
      maped_name_pp = {CLOBBER};
    }
}


mono_assembly_apply_binding (struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  unsigned char D.20253;
  struct MonoAssemblyName * D.20256;
  union mono_mutex_t * D.20259;
  _Bool D.20262;
  long int D.20263;
  long int D.20264;
  _Bool D.20269;
  long int D.20270;
  long int D.20271;
  int D.20276;
  struct MonoAppDomainSetup * D.20281;
  struct MonoString * D.20284;
  _Bool D.20289;
  long int D.20290;
  long int D.20291;
  int D.20294;
  short unsigned int D.20299;
  int D.20300;
  short unsigned int D.20301;
  int D.20302;
  char * D.20307;
  gchar * D.20308;
  char * D.20309;
  gchar * D.20310;
  int D.20311;
  _Bool D.20314;
  long int D.20315;
  long int D.20316;
  unsigned char D.20321;
  unsigned char D.20322;
  const char * D.20329;
  gchar * D.20330;
  const char * D.20331;
  gchar * D.20332;
  mono_byte[17] * D.20333;
  guchar[17] * D.20334;
  struct GSList * loaded_assembly_bindings.100;
  struct GSList * loaded_assembly_bindings.101;
  int D.20343;
  struct MonoAssemblyBindingInfo * info;
  struct MonoAssemblyBindingInfo * info2;
  struct MonoImage * ppimage;
  struct MonoDomain * domain;

  D.20253 = aname->public_key_token[0];
  if (D.20253 == 0) goto <D.20254>; else goto <D.20255>;
  <D.20254>:
  D.20256 = aname;
  return D.20256;
  <D.20255>:
  domain = mono_domain_get ();
  mono_assembly_binding_lock ();
  info = search_binding_loaded (aname);
  mono_assembly_binding_unlock ();
  if (info == 0B) goto <D.20257>; else goto <D.20258>;
  <D.20257>:
  {
    int ret;

    D.20259 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20259);
    if (ret != 0) goto <D.20260>; else goto <D.20261>;
    <D.20260>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20261>:
    D.20262 = ret != 0;
    D.20263 = (long int) D.20262;
    D.20264 = __builtin_expect (D.20263, 0);
    if (D.20264 != 0) goto <D.20265>; else goto <D.20266>;
    <D.20265>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2644, "ret == 0");
    <D.20266>:
  }
  info = get_per_domain_assembly_binding_info (domain, aname);
  {
    int ret;

    D.20259 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20259);
    if (ret != 0) goto <D.20267>; else goto <D.20268>;
    <D.20267>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20268>:
    D.20269 = ret != 0;
    D.20270 = (long int) D.20269;
    D.20271 = __builtin_expect (D.20270, 0);
    if (D.20271 != 0) goto <D.20272>; else goto <D.20273>;
    <D.20272>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2646, "ret == 0");
    <D.20273>:
  }
  <D.20258>:
  if (info != 0B) goto <D.20274>; else goto <D.20275>;
  <D.20274>:
  D.20276 = check_policy_versions (info, aname);
  if (D.20276 == 0) goto <D.20277>; else goto <D.20278>;
  <D.20277>:
  D.20256 = aname;
  return D.20256;
  <D.20278>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.20256 = dest_name;
  return D.20256;
  <D.20275>:
  if (domain != 0B) goto <D.20279>; else goto <D.20280>;
  <D.20279>:
  D.20281 = domain->setup;
  if (D.20281 != 0B) goto <D.20282>; else goto <D.20283>;
  <D.20282>:
  D.20281 = domain->setup;
  D.20284 = D.20281->configuration_file;
  if (D.20284 != 0B) goto <D.20285>; else goto <D.20286>;
  <D.20285>:
  {
    int ret;

    D.20259 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20259);
    if (ret != 0) goto <D.20287>; else goto <D.20288>;
    <D.20287>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20288>:
    D.20289 = ret != 0;
    D.20290 = (long int) D.20289;
    D.20291 = __builtin_expect (D.20290, 0);
    if (D.20291 != 0) goto <D.20292>; else goto <D.20293>;
    <D.20292>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2658, "ret == 0");
    <D.20293>:
  }
  D.20294 = domain->assembly_bindings_parsed;
  if (D.20294 == 0) goto <D.20295>; else goto <D.20296>;
  <D.20295>:
  {
    gchar * domain_config_file_name;
    gchar * domain_config_file_path;

    D.20281 = domain->setup;
    D.20284 = D.20281->configuration_file;
    domain_config_file_name = mono_string_to_utf8 (D.20284);
    domain_config_file_path = mono_portability_find_file (domain_config_file_name, 1);
    if (domain_config_file_path == 0B) goto <D.20297>; else goto <D.20298>;
    <D.20297>:
    domain_config_file_path = domain_config_file_name;
    <D.20298>:
    D.20299 = aname->minor;
    D.20300 = (int) D.20299;
    D.20301 = aname->major;
    D.20302 = (int) D.20301;
    mono_config_parse_assembly_bindings (domain_config_file_path, D.20302, D.20300, domain, assembly_binding_info_parsed);
    domain->assembly_bindings_parsed = 1;
    if (domain_config_file_name != domain_config_file_path) goto <D.20303>; else goto <D.20304>;
    <D.20303>:
    monoeg_g_free (domain_config_file_name);
    <D.20304>:
    monoeg_g_free (domain_config_file_path);
  }
  <D.20296>:
  info2 = get_per_domain_assembly_binding_info (domain, aname);
  if (info2 != 0B) goto <D.20305>; else goto <D.20306>;
  <D.20305>:
  info = monoeg_g_memdup (info2, 68);
  D.20307 = info2->name;
  D.20308 = monoeg_strdup (D.20307);
  info->name = D.20308;
  D.20309 = info2->culture;
  D.20310 = monoeg_strdup (D.20309);
  info->culture = D.20310;
  D.20311 = domain->domain_id;
  info->domain_id = D.20311;
  <D.20306>:
  {
    int ret;

    D.20259 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20259);
    if (ret != 0) goto <D.20312>; else goto <D.20313>;
    <D.20312>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20313>:
    D.20314 = ret != 0;
    D.20315 = (long int) D.20314;
    D.20316 = __builtin_expect (D.20315, 0);
    if (D.20316 != 0) goto <D.20317>; else goto <D.20318>;
    <D.20317>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 2682, "ret == 0");
    <D.20318>:
  }
  <D.20286>:
  <D.20283>:
  <D.20280>:
  if (info == 0B) goto <D.20319>; else goto <D.20320>;
  <D.20319>:
  info = monoeg_malloc0 (68);
  D.20301 = aname->major;
  D.20302 = (int) D.20301;
  info->major = D.20302;
  D.20299 = aname->minor;
  D.20300 = (int) D.20299;
  info->minor = D.20300;
  <D.20320>:
  D.20321 = BIT_FIELD_REF <*info, 8, 480>;
  D.20322 = D.20321 & 8;
  if (D.20322 == 0) goto <D.20323>; else goto <D.20324>;
  <D.20323>:
  ppimage = mono_assembly_load_publisher_policy (aname);
  if (ppimage != 0B) goto <D.20325>; else goto <D.20326>;
  <D.20325>:
  get_publisher_policy_info (ppimage, aname, info);
  mono_image_close (ppimage);
  <D.20326>:
  <D.20324>:
  D.20321 = BIT_FIELD_REF <*info, 8, 480>;
  D.20322 = D.20321 & 8;
  if (D.20322 == 0) goto <D.20327>; else goto <D.20328>;
  <D.20327>:
  D.20329 = aname->name;
  D.20330 = monoeg_strdup (D.20329);
  info->name = D.20330;
  D.20331 = aname->culture;
  D.20332 = monoeg_strdup (D.20331);
  info->culture = D.20332;
  D.20333 = &aname->public_key_token;
  D.20334 = &info->public_key_token;
  monoeg_g_strlcpy (D.20334, D.20333, 17);
  <D.20328>:
  mono_assembly_binding_lock ();
  info2 = search_binding_loaded (aname);
  if (info2 != 0B) goto <D.20335>; else goto <D.20336>;
  <D.20335>:
  mono_assembly_binding_info_free (info);
  monoeg_g_free (info);
  info = info2;
  goto <D.20337>;
  <D.20336>:
  loaded_assembly_bindings.100 = loaded_assembly_bindings;
  loaded_assembly_bindings.101 = monoeg_g_slist_prepend (loaded_assembly_bindings.100, info);
  loaded_assembly_bindings = loaded_assembly_bindings.101;
  <D.20337>:
  mono_assembly_binding_unlock ();
  D.20321 = BIT_FIELD_REF <*info, 8, 480>;
  D.20322 = D.20321 & 8;
  if (D.20322 == 0) goto <D.20340>; else goto <D.20342>;
  <D.20342>:
  D.20343 = check_policy_versions (info, aname);
  if (D.20343 == 0) goto <D.20340>; else goto <D.20341>;
  <D.20340>:
  D.20256 = aname;
  return D.20256;
  <D.20341>:
  mono_assembly_bind_version (info, aname, dest_name);
  D.20256 = dest_name;
  return D.20256;
}


assembly_binding_info_parsed (struct MonoAssemblyBindingInfo * info, void * user_data)
{
  int D.17849;
  char * D.20347;
  char * D.20348;
  int D.20351;
  struct MonoMemPool * D.20354;
  char * D.20357;
  char * D.20358;
  char * D.20361;
  struct GSList * D.20362;
  struct GSList * D.20363;
  struct MonoAssemblyBindingInfo * info_copy;
  struct GSList * tmp;
  struct MonoAssemblyBindingInfo * info_tmp;
  struct MonoDomain * domain;

  domain = user_data;
  if (domain == 0B) goto <D.20345>; else goto <D.20346>;
  <D.20345>:
  return;
  <D.20346>:
  tmp = domain->assembly_bindings;
  goto <D.17851>;
  <D.17850>:
  info_tmp = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20347 = info_tmp->name;
    D.20348 = info->name;
    D.17849 = __builtin_strcmp (D.20348, D.20347);
  }
  if (D.17849 == 0) goto <D.20349>; else goto <D.20350>;
  <D.20349>:
  D.20351 = info_versions_equal (info, info_tmp);
  if (D.20351 != 0) goto <D.20352>; else goto <D.20353>;
  <D.20352>:
  return;
  <D.20353>:
  <D.20350>:
  tmp = tmp->next;
  <D.17851>:
  if (tmp != 0B) goto <D.17850>; else goto <D.17852>;
  <D.17852>:
  D.20354 = domain->mp;
  info_copy = mono_mempool_alloc0 (D.20354, 68);
  memcpy (info_copy, info, 68);
  D.20348 = info->name;
  if (D.20348 != 0B) goto <D.20355>; else goto <D.20356>;
  <D.20355>:
  D.20348 = info->name;
  D.20354 = domain->mp;
  D.20357 = mono_mempool_strdup (D.20354, D.20348);
  info_copy->name = D.20357;
  <D.20356>:
  D.20358 = info->culture;
  if (D.20358 != 0B) goto <D.20359>; else goto <D.20360>;
  <D.20359>:
  D.20358 = info->culture;
  D.20354 = domain->mp;
  D.20361 = mono_mempool_strdup (D.20354, D.20358);
  info_copy->culture = D.20361;
  <D.20360>:
  D.20362 = domain->assembly_bindings;
  D.20354 = domain->mp;
  D.20363 = g_slist_append_mempool (D.20354, D.20362, info_copy);
  domain->assembly_bindings = D.20363;
}


info_versions_equal (struct MonoAssemblyBindingInfo * left, struct MonoAssemblyBindingInfo * right)
{
  unsigned char D.20365;
  unsigned char D.20366;
  unsigned char D.20367;
  unsigned char D.20368;
  gboolean D.20371;
  unsigned char D.20372;
  unsigned char D.20375;
  unsigned char D.20378;
  struct AssemblyVersionSet * D.20381;
  struct AssemblyVersionSet * D.20382;
  int D.20383;
  unsigned char D.20386;
  struct AssemblyVersionSet * D.20389;
  struct AssemblyVersionSet * D.20390;
  int D.20391;
  unsigned char D.20394;
  struct AssemblyVersionSet * D.20397;
  struct AssemblyVersionSet * D.20398;
  int D.20399;

  D.20365 = BIT_FIELD_REF <*left, 8, 480>;
  D.20366 = BIT_FIELD_REF <*right, 8, 480>;
  D.20367 = D.20365 ^ D.20366;
  D.20368 = D.20367 & 1;
  if (D.20368 != 0) goto <D.20369>; else goto <D.20370>;
  <D.20369>:
  D.20371 = 0;
  return D.20371;
  <D.20370>:
  D.20365 = BIT_FIELD_REF <*left, 8, 480>;
  D.20366 = BIT_FIELD_REF <*right, 8, 480>;
  D.20367 = D.20365 ^ D.20366;
  D.20372 = D.20367 & 2;
  if (D.20372 != 0) goto <D.20373>; else goto <D.20374>;
  <D.20373>:
  D.20371 = 0;
  return D.20371;
  <D.20374>:
  D.20365 = BIT_FIELD_REF <*left, 8, 480>;
  D.20366 = BIT_FIELD_REF <*right, 8, 480>;
  D.20367 = D.20365 ^ D.20366;
  D.20375 = D.20367 & 4;
  if (D.20375 != 0) goto <D.20376>; else goto <D.20377>;
  <D.20376>:
  D.20371 = 0;
  return D.20371;
  <D.20377>:
  D.20365 = BIT_FIELD_REF <*left, 8, 480>;
  D.20378 = D.20365 & 1;
  if (D.20378 != 0) goto <D.20379>; else goto <D.20380>;
  <D.20379>:
  D.20381 = &right->old_version_bottom;
  D.20382 = &left->old_version_bottom;
  D.20383 = info_compare_versions (D.20382, D.20381);
  if (D.20383 == 0) goto <D.20384>; else goto <D.20385>;
  <D.20384>:
  D.20371 = 0;
  return D.20371;
  <D.20385>:
  <D.20380>:
  D.20365 = BIT_FIELD_REF <*left, 8, 480>;
  D.20386 = D.20365 & 2;
  if (D.20386 != 0) goto <D.20387>; else goto <D.20388>;
  <D.20387>:
  D.20389 = &right->old_version_top;
  D.20390 = &left->old_version_top;
  D.20391 = info_compare_versions (D.20390, D.20389);
  if (D.20391 == 0) goto <D.20392>; else goto <D.20393>;
  <D.20392>:
  D.20371 = 0;
  return D.20371;
  <D.20393>:
  <D.20388>:
  D.20365 = BIT_FIELD_REF <*left, 8, 480>;
  D.20394 = D.20365 & 4;
  if (D.20394 != 0) goto <D.20395>; else goto <D.20396>;
  <D.20395>:
  D.20397 = &right->new_version;
  D.20398 = &left->new_version;
  D.20399 = info_compare_versions (D.20398, D.20397);
  if (D.20399 == 0) goto <D.20400>; else goto <D.20401>;
  <D.20400>:
  D.20371 = 0;
  return D.20371;
  <D.20401>:
  <D.20396>:
  D.20371 = 1;
  return D.20371;
}


info_compare_versions (struct AssemblyVersionSet * left, struct AssemblyVersionSet * right)
{
  short unsigned int D.20405;
  short unsigned int D.20406;
  short unsigned int D.20408;
  short unsigned int D.20409;
  short unsigned int D.20411;
  short unsigned int D.20412;
  short unsigned int D.20414;
  short unsigned int D.20415;
  gboolean D.20416;

  D.20405 = left->major;
  D.20406 = right->major;
  if (D.20405 != D.20406) goto <D.20403>; else goto <D.20407>;
  <D.20407>:
  D.20408 = left->minor;
  D.20409 = right->minor;
  if (D.20408 != D.20409) goto <D.20403>; else goto <D.20410>;
  <D.20410>:
  D.20411 = left->build;
  D.20412 = right->build;
  if (D.20411 != D.20412) goto <D.20403>; else goto <D.20413>;
  <D.20413>:
  D.20414 = left->revision;
  D.20415 = right->revision;
  if (D.20414 != D.20415) goto <D.20403>; else goto <D.20404>;
  <D.20403>:
  D.20416 = 0;
  return D.20416;
  <D.20404>:
  D.20416 = 1;
  return D.20416;
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.20420;
  struct GSList * D.20421;
  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.20418>; else goto <D.20419>;
  <D.20418>:
  last = list;
  goto <D.10469>;
  <D.10468>:
  last = last->next;
  <D.10469>:
  D.20420 = last->next;
  if (D.20420 != 0B) goto <D.10468>; else goto <D.10470>;
  <D.10470>:
  last->next = new_list;
  D.20421 = list;
  return D.20421;
  <D.20419>:
  D.20421 = new_list;
  return D.20421;
}


get_per_domain_assembly_binding_info (struct MonoDomain * domain, struct MonoAssemblyName * aname)
{
  struct GSList * D.20423;
  struct MonoAssemblyBindingInfo * D.20426;
  int D.17876;
  char * D.20429;
  const char * D.20430;
  int D.20433;
  unsigned char D.20440;
  unsigned char D.20442;
  unsigned char D.20443;
  int D.20445;
  struct MonoAssemblyBindingInfo * info;
  struct GSList * list;

  D.20423 = domain->assembly_bindings;
  if (D.20423 == 0B) goto <D.20424>; else goto <D.20425>;
  <D.20424>:
  D.20426 = 0B;
  return D.20426;
  <D.20425>:
  info = 0B;
  list = domain->assembly_bindings;
  goto <D.17879>;
  <D.17878>:
  info = list->data;
  if (info != 0B) goto <D.20427>; else goto <D.20428>;
  <D.20427>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20429 = info->name;
    D.20430 = aname->name;
    D.17876 = __builtin_strcmp (D.20430, D.20429);
  }
  if (D.17876 == 0) goto <D.20431>; else goto <D.20432>;
  <D.20431>:
  D.20433 = info_major_minor_in_range (info, aname);
  if (D.20433 != 0) goto <D.17877>; else goto <D.20434>;
  <D.20434>:
  <D.20432>:
  <D.20428>:
  info = 0B;
  list = list->next;
  <D.17879>:
  if (list != 0B) goto <D.17878>; else goto <D.17877>;
  <D.17877>:
  if (info != 0B) goto <D.20435>; else goto <D.20436>;
  <D.20435>:
  D.20429 = info->name;
  if (D.20429 != 0B) goto <D.20439>; else goto <D.20437>;
  <D.20439>:
  D.20440 = info->public_key_token[0];
  if (D.20440 != 0) goto <D.20441>; else goto <D.20437>;
  <D.20441>:
  D.20442 = BIT_FIELD_REF <*info, 8, 480>;
  D.20443 = D.20442 & 5;
  if (D.20443 == 5) goto <D.20444>; else goto <D.20437>;
  <D.20444>:
  D.20445 = assembly_binding_maps_name (info, aname);
  if (D.20445 != 0) goto <D.20446>; else goto <D.20437>;
  <D.20446>:
  info->is_valid = 1;
  goto <D.20438>;
  <D.20437>:
  info->is_valid = 0;
  <D.20438>:
  <D.20436>:
  D.20426 = info;
  return D.20426;
}


info_major_minor_in_range (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  short unsigned int D.20448;
  int D.20449;
  short unsigned int D.20450;
  int D.20451;
  unsigned char D.20452;
  unsigned char D.20453;
  gboolean D.20456;
  short unsigned int D.20457;
  int D.20458;
  short unsigned int D.20459;
  int D.20460;
  int D.20461;
  unsigned char D.20464;
  short unsigned int D.20467;
  int D.20468;
  short unsigned int D.20469;
  int D.20470;
  int D.20471;
  int aname_version_number;

  D.20448 = aname->minor;
  D.20449 = (int) D.20448;
  D.20450 = aname->major;
  D.20451 = (int) D.20450;
  aname_version_number = get_version_number (D.20451, D.20449);
  D.20452 = BIT_FIELD_REF <*info, 8, 480>;
  D.20453 = D.20452 & 1;
  if (D.20453 == 0) goto <D.20454>; else goto <D.20455>;
  <D.20454>:
  D.20456 = 0;
  return D.20456;
  <D.20455>:
  D.20457 = info->old_version_bottom.minor;
  D.20458 = (int) D.20457;
  D.20459 = info->old_version_bottom.major;
  D.20460 = (int) D.20459;
  D.20461 = get_version_number (D.20460, D.20458);
  if (D.20461 > aname_version_number) goto <D.20462>; else goto <D.20463>;
  <D.20462>:
  D.20456 = 0;
  return D.20456;
  <D.20463>:
  D.20452 = BIT_FIELD_REF <*info, 8, 480>;
  D.20464 = D.20452 & 2;
  if (D.20464 != 0) goto <D.20465>; else goto <D.20466>;
  <D.20465>:
  D.20467 = info->old_version_top.minor;
  D.20468 = (int) D.20467;
  D.20469 = info->old_version_top.major;
  D.20470 = (int) D.20469;
  D.20471 = get_version_number (D.20470, D.20468);
  if (D.20471 < aname_version_number) goto <D.20472>; else goto <D.20473>;
  <D.20472>:
  D.20456 = 0;
  return D.20456;
  <D.20473>:
  <D.20466>:
  D.20450 = aname->major;
  D.20451 = (int) D.20450;
  info->major = D.20451;
  D.20448 = aname->minor;
  D.20449 = (int) D.20448;
  info->minor = D.20449;
  D.20456 = 1;
  return D.20456;
}


get_version_number (int major, int minor)
{
  int D.20475;
  int D.20476;

  D.20476 = major * 256;
  D.20475 = D.20476 + minor;
  return D.20475;
}


assembly_binding_maps_name (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname)
{
  char * D.20481;
  gboolean D.20482;
  int D.16988;
  const char * D.20483;
  int D.20488;
  short unsigned int D.20489;
  int D.20490;
  int D.20492;
  short unsigned int D.20493;
  int D.20494;
  int iftmp.102;
  char * D.20498;
  char D.20500;
  _Bool D.20502;
  int iftmp.103;
  const char * D.20506;
  char D.20508;
  _Bool D.20510;
  _Bool D.20511;
  int D.16997;
  mono_byte[17] * D.20520;
  guchar[17] * D.20521;
  int D.20522;

  if (info == 0B) goto <D.20478>; else goto <D.20480>;
  <D.20480>:
  D.20481 = info->name;
  if (D.20481 == 0B) goto <D.20478>; else goto <D.20479>;
  <D.20478>:
  D.20482 = 0;
  return D.20482;
  <D.20479>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20483 = aname->name;
    D.20481 = info->name;
    D.16988 = __builtin_strcmp (D.20481, D.20483);
  }
  if (D.16988 != 0) goto <D.20484>; else goto <D.20485>;
  <D.20484>:
  D.20482 = 0;
  return D.20482;
  <D.20485>:
  D.20488 = info->major;
  D.20489 = aname->major;
  D.20490 = (int) D.20489;
  if (D.20488 != D.20490) goto <D.20486>; else goto <D.20491>;
  <D.20491>:
  D.20492 = info->minor;
  D.20493 = aname->minor;
  D.20494 = (int) D.20493;
  if (D.20492 != D.20494) goto <D.20486>; else goto <D.20487>;
  <D.20486>:
  D.20482 = 0;
  return D.20482;
  <D.20487>:
  D.20498 = info->culture;
  if (D.20498 != 0B) goto <D.20499>; else goto <D.20496>;
  <D.20499>:
  D.20498 = info->culture;
  D.20500 = *D.20498;
  if (D.20500 != 0) goto <D.20501>; else goto <D.20496>;
  <D.20501>:
  iftmp.102 = 1;
  goto <D.20497>;
  <D.20496>:
  iftmp.102 = 0;
  <D.20497>:
  D.20502 = (_Bool) iftmp.102;
  D.20506 = aname->culture;
  if (D.20506 != 0B) goto <D.20507>; else goto <D.20504>;
  <D.20507>:
  D.20506 = aname->culture;
  D.20508 = *D.20506;
  if (D.20508 != 0) goto <D.20509>; else goto <D.20504>;
  <D.20509>:
  iftmp.103 = 1;
  goto <D.20505>;
  <D.20504>:
  iftmp.103 = 0;
  <D.20505>:
  D.20510 = (_Bool) iftmp.103;
  D.20511 = D.20502 ^ D.20510;
  if (D.20511 != 0) goto <D.20512>; else goto <D.20513>;
  <D.20512>:
  D.20482 = 0;
  return D.20482;
  <D.20513>:
  D.20498 = info->culture;
  if (D.20498 != 0B) goto <D.20514>; else goto <D.20515>;
  <D.20514>:
  D.20506 = aname->culture;
  if (D.20506 != 0B) goto <D.20516>; else goto <D.20517>;
  <D.20516>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20506 = aname->culture;
    D.20498 = info->culture;
    D.16997 = __builtin_strcmp (D.20498, D.20506);
  }
  if (D.16997 != 0) goto <D.20518>; else goto <D.20519>;
  <D.20518>:
  D.20482 = 0;
  return D.20482;
  <D.20519>:
  <D.20517>:
  <D.20515>:
  D.20520 = &aname->public_key_token;
  D.20521 = &info->public_key_token;
  D.20522 = mono_public_tokens_are_equal (D.20521, D.20520);
  if (D.20522 == 0) goto <D.20523>; else goto <D.20524>;
  <D.20523>:
  D.20482 = 0;
  return D.20482;
  <D.20524>:
  D.20482 = 1;
  return D.20482;
}


mono_assembly_load_publisher_policy (struct MonoAssemblyName * aname)
{
  const char * D.20526;
  char * D.20527;
  unsigned int D.20530;
  unsigned int D.20531;
  unsigned int len.104;
  unsigned int len.105;
  const char * D.20535;
  short unsigned int D.20539;
  int D.20540;
  short unsigned int D.20541;
  int D.20542;
  mono_byte[17] * D.20543;
  char * * extra_gac_paths.106;
  gchar * D.20547;
  struct MonoImage * D.20551;
  const char * D.20552;
  struct MonoImage * image;
  gchar * filename;
  gchar * pname;
  gchar * name;
  gchar * culture;
  gchar * version;
  gchar * fullpath;
  gchar * subpath;
  gchar * * paths;
  gint32 len;

  D.20526 = aname->name;
  D.20527 = strstr (D.20526, ".dll");
  if (D.20527 != 0B) goto <D.20528>; else goto <D.20529>;
  <D.20528>:
  D.20526 = aname->name;
  D.20530 = strlen (D.20526);
  D.20531 = D.20530 + 4294967292;
  len = (gint32) D.20531;
  len.104 = (unsigned int) len;
  name = monoeg_malloc (len.104);
  len.105 = (unsigned int) len;
  D.20526 = aname->name;
  strncpy (name, D.20526, len.105);
  goto <D.20534>;
  <D.20529>:
  D.20526 = aname->name;
  name = monoeg_strdup (D.20526);
  <D.20534>:
  D.20535 = aname->culture;
  if (D.20535 != 0B) goto <D.20536>; else goto <D.20537>;
  <D.20536>:
  D.20535 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.20535, -1);
  goto <D.20538>;
  <D.20537>:
  culture = monoeg_strdup ("");
  <D.20538>:
  D.20539 = aname->minor;
  D.20540 = (int) D.20539;
  D.20541 = aname->major;
  D.20542 = (int) D.20541;
  pname = monoeg_g_strdup_printf ("policy.%d.%d.%s", D.20542, D.20540, name);
  D.20543 = &aname->public_key_token;
  version = monoeg_g_strdup_printf ("0.0.0.0_%s_%s", culture, D.20543);
  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.106 = extra_gac_paths;
  if (extra_gac_paths.106 != 0B) goto <D.20545>; else goto <D.20546>;
  <D.20545>:
  paths = extra_gac_paths;
  goto <D.17810>;
  <D.17809>:
  D.20547 = *paths;
  fullpath = monoeg_g_build_path ("/", D.20547, "lib", "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (fullpath);
  paths = paths + 4;
  <D.17810>:
  if (image == 0B) goto <D.20548>; else goto <D.17811>;
  <D.20548>:
  D.20547 = *paths;
  if (D.20547 != 0B) goto <D.17809>; else goto <D.17811>;
  <D.17811>:
  <D.20546>:
  if (image != 0B) goto <D.20549>; else goto <D.20550>;
  <D.20549>:
  monoeg_g_free (subpath);
  D.20551 = image;
  return D.20551;
  <D.20550>:
  D.20552 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.20552, "mono", "gac", subpath, 0B);
  image = mono_image_open (fullpath, 0B);
  monoeg_g_free (subpath);
  monoeg_g_free (fullpath);
  D.20551 = image;
  return D.20551;
}


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

  D.20555 = __builtin_object_size (__dest, 1);
  D.20554 = __builtin___strncpy_chk (__dest, __src, __len, D.20555);
  return D.20554;
}


get_publisher_policy_info (struct MonoImage * image, struct MonoAssemblyName * aname, struct MonoAssemblyBindingInfo * binding_info)
{
  <unnamed-unsigned:24> D.20557;
  int D.20558;
  unsigned int D.20561;
  unsigned int D.20562;
  unsigned int D.20565;
  _Bool D.20566;
  long int D.20567;
  long int D.20568;
  char * D.20571;
  char * D.20572;
  gchar * D.20575;
  char * D.20578;
  unsigned char D.20580;
  unsigned char D.20582;
  unsigned char D.20583;
  int D.20585;
  struct MonoTableInfo * t;
  guint32 cols[4];
  const gchar * filename;
  gchar * subpath;
  gchar * fullpath;

  try
    {
      t = &image->tables[40];
      D.20557 = t->rows;
      D.20558 = (int) D.20557;
      if (D.20558 <= 0) goto <D.20559>; else goto <D.20560>;
      <D.20559>:
      binding_info->is_valid = 0;
      return;
      <D.20560>:
      mono_metadata_decode_row (t, 0, &cols, 4);
      D.20561 = cols[3];
      D.20562 = D.20561 & 3;
      if (D.20562 != 0) goto <D.20563>; else goto <D.20564>;
      <D.20563>:
      binding_info->is_valid = 0;
      return;
      <D.20564>:
      D.20565 = cols[2];
      filename = mono_metadata_string_heap (image, D.20565);
      D.20566 = filename == 0B;
      D.20567 = (long int) D.20566;
      D.20568 = __builtin_expect (D.20567, 0);
      if (D.20568 != 0) goto <D.20569>; else goto <D.20570>;
      <D.20569>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 370, "filename != NULL");
      <D.20570>:
      D.20571 = image->name;
      subpath = monoeg_g_path_get_dirname (D.20571);
      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.20572 = binding_info->culture;
      if (D.20572 == 0B) goto <D.20573>; else goto <D.20574>;
      <D.20573>:
      D.20575 = monoeg_strdup ("");
      binding_info->culture = D.20575;
      <D.20574>:
      D.20578 = binding_info->name;
      if (D.20578 == 0B) goto <D.20576>; else goto <D.20579>;
      <D.20579>:
      D.20580 = binding_info->public_key_token[0];
      if (D.20580 == 0) goto <D.20576>; else goto <D.20581>;
      <D.20581>:
      D.20582 = BIT_FIELD_REF <*binding_info, 8, 480>;
      D.20583 = D.20582 & 5;
      if (D.20583 != 5) goto <D.20576>; else goto <D.20584>;
      <D.20584>:
      D.20585 = assembly_binding_maps_name (binding_info, aname);
      if (D.20585 == 0) goto <D.20576>; else goto <D.20577>;
      <D.20576>:
      mono_assembly_binding_info_free (binding_info);
      binding_info->is_valid = 0;
      return;
      <D.20577>:
      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.20589;
  struct MonoAssemblyBindingInfo * D.20592;
  struct GSList * tmp;

  tmp = loaded_assembly_bindings;
  goto <D.17823>;
  <D.17822>:
  {
    struct MonoAssemblyBindingInfo * info;

    info = tmp->data;
    D.20589 = assembly_binding_maps_name (info, aname);
    if (D.20589 != 0) goto <D.20590>; else goto <D.20591>;
    <D.20590>:
    D.20592 = info;
    return D.20592;
    <D.20591>:
  }
  tmp = tmp->next;
  <D.17823>:
  if (tmp != 0B) goto <D.17822>; else goto <D.17824>;
  <D.17824>:
  D.20592 = 0B;
  return D.20592;
}


mono_assembly_binding_info_free (struct MonoAssemblyBindingInfo * info)
{
  char * D.20596;
  char * D.20597;

  if (info == 0B) goto <D.20594>; else goto <D.20595>;
  <D.20594>:
  return;
  <D.20595>:
  D.20596 = info->name;
  monoeg_g_free (D.20596);
  D.20597 = info->culture;
  monoeg_g_free (D.20597);
}


mono_assembly_binding_unlock ()
{
  pthread_mutex_unlock (&assembly_binding_mutex);
}


check_policy_versions (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * name)
{
  unsigned char D.20599;
  unsigned char D.20600;
  gboolean D.20603;
  unsigned char D.20604;
  struct AssemblyVersionSet * D.20607;
  int D.20608;
  struct AssemblyVersionSet * D.20611;
  int D.20612;
  int D.20615;

  D.20599 = BIT_FIELD_REF <*info, 8, 480>;
  D.20600 = D.20599 & 8;
  if (D.20600 == 0) goto <D.20601>; else goto <D.20602>;
  <D.20601>:
  D.20603 = 0;
  return D.20603;
  <D.20602>:
  D.20599 = BIT_FIELD_REF <*info, 8, 480>;
  D.20604 = D.20599 & 2;
  if (D.20604 == 0) goto <D.20605>; else goto <D.20606>;
  <D.20605>:
  D.20607 = &info->old_version_bottom;
  D.20608 = compare_versions (D.20607, name);
  if (D.20608 == 0) goto <D.20609>; else goto <D.20610>;
  <D.20609>:
  D.20603 = 1;
  return D.20603;
  <D.20610>:
  D.20603 = 0;
  return D.20603;
  <D.20606>:
  D.20611 = &info->old_version_top;
  D.20612 = compare_versions (D.20611, name);
  if (D.20612 < 0) goto <D.20613>; else goto <D.20614>;
  <D.20613>:
  D.20603 = 0;
  return D.20603;
  <D.20614>:
  D.20607 = &info->old_version_bottom;
  D.20615 = compare_versions (D.20607, name);
  if (D.20615 > 0) goto <D.20616>; else goto <D.20617>;
  <D.20616>:
  D.20603 = 0;
  return D.20603;
  <D.20617>:
  D.20603 = 1;
  return D.20603;
}


compare_versions (struct AssemblyVersionSet * v, struct MonoAssemblyName * aname)
{
  short unsigned int D.20619;
  short unsigned int D.20620;
  int D.20623;
  short unsigned int D.20626;
  short unsigned int D.20627;
  short unsigned int D.20632;
  short unsigned int D.20633;
  short unsigned int D.20638;
  short unsigned int D.20639;

  D.20619 = v->major;
  D.20620 = aname->major;
  if (D.20619 > D.20620) goto <D.20621>; else goto <D.20622>;
  <D.20621>:
  D.20623 = 1;
  return D.20623;
  <D.20622>:
  D.20619 = v->major;
  D.20620 = aname->major;
  if (D.20619 < D.20620) goto <D.20624>; else goto <D.20625>;
  <D.20624>:
  D.20623 = -1;
  return D.20623;
  <D.20625>:
  D.20626 = v->minor;
  D.20627 = aname->minor;
  if (D.20626 > D.20627) goto <D.20628>; else goto <D.20629>;
  <D.20628>:
  D.20623 = 1;
  return D.20623;
  <D.20629>:
  D.20626 = v->minor;
  D.20627 = aname->minor;
  if (D.20626 < D.20627) goto <D.20630>; else goto <D.20631>;
  <D.20630>:
  D.20623 = -1;
  return D.20623;
  <D.20631>:
  D.20632 = v->build;
  D.20633 = aname->build;
  if (D.20632 > D.20633) goto <D.20634>; else goto <D.20635>;
  <D.20634>:
  D.20623 = 1;
  return D.20623;
  <D.20635>:
  D.20632 = v->build;
  D.20633 = aname->build;
  if (D.20632 < D.20633) goto <D.20636>; else goto <D.20637>;
  <D.20636>:
  D.20623 = -1;
  return D.20623;
  <D.20637>:
  D.20638 = v->revision;
  D.20639 = aname->revision;
  if (D.20638 > D.20639) goto <D.20640>; else goto <D.20641>;
  <D.20640>:
  D.20623 = 1;
  return D.20623;
  <D.20641>:
  D.20638 = v->revision;
  D.20639 = aname->revision;
  if (D.20638 < D.20639) goto <D.20642>; else goto <D.20643>;
  <D.20642>:
  D.20623 = -1;
  return D.20623;
  <D.20643>:
  D.20623 = 0;
  return D.20623;
}


mono_assembly_bind_version (struct MonoAssemblyBindingInfo * info, struct MonoAssemblyName * aname, struct MonoAssemblyName * dest_name)
{
  short unsigned int D.20645;
  short unsigned int D.20646;
  short unsigned int D.20647;
  short unsigned int D.20648;
  struct MonoAssemblyName * D.20649;

  memcpy (dest_name, aname, 60);
  D.20645 = info->new_version.major;
  dest_name->major = D.20645;
  D.20646 = info->new_version.minor;
  dest_name->minor = D.20646;
  D.20647 = info->new_version.build;
  dest_name->build = D.20647;
  D.20648 = info->new_version.revision;
  dest_name->revision = D.20648;
  D.20649 = dest_name;
  return D.20649;
}


invoke_assembly_refonly_preload_hook (struct MonoAssemblyName * aname, gchar * * assemblies_path)
{
  struct MonoAssembly * (*<Te89>) (struct MonoAssemblyName *, char * *, void *) D.20651;
  void * D.20652;
  struct MonoAssembly * D.20655;
  struct AssemblyPreLoadHook * hook;
  struct MonoAssembly * assembly;

  hook = assembly_refonly_preload_hook;
  goto <D.17391>;
  <D.17390>:
  D.20651 = hook->func;
  D.20652 = hook->user_data;
  assembly = D.20651 (aname, assemblies_path, D.20652);
  if (assembly != 0B) goto <D.20653>; else goto <D.20654>;
  <D.20653>:
  D.20655 = assembly;
  return D.20655;
  <D.20654>:
  hook = hook->next;
  <D.17391>:
  if (hook != 0B) goto <D.17390>; else goto <D.17392>;
  <D.17392>:
  D.20655 = 0B;
  return D.20655;
}


mono_assembly_load_from_gac (struct MonoAssemblyName * aname, gchar * filename, MonoImageOpenStatus * status, MonoBoolean refonly)
{
  unsigned char D.20657;
  struct MonoAssembly * D.20660;
  const char * D.20661;
  char * D.20662;
  unsigned int D.20665;
  unsigned int D.20666;
  unsigned int len.107;
  unsigned int len.108;
  const char * D.20670;
  mono_byte[17] * D.20674;
  short unsigned int D.20675;
  int D.20676;
  short unsigned int D.20677;
  int D.20678;
  short unsigned int D.20679;
  int D.20680;
  short unsigned int D.20681;
  int D.20682;
  char * * extra_gac_paths.109;
  gchar * D.20686;
  int D.20687;
  const char * D.20691;
  struct MonoAssembly * result;
  gchar * name;
  gchar * version;
  gchar * culture;
  gchar * fullpath;
  gchar * subpath;
  gint32 len;
  gchar * * paths;
  char * pubtok;

  result = 0B;
  D.20657 = aname->public_key_token[0];
  if (D.20657 == 0) goto <D.20658>; else goto <D.20659>;
  <D.20658>:
  D.20660 = 0B;
  return D.20660;
  <D.20659>:
  D.20661 = aname->name;
  D.20662 = strstr (D.20661, ".dll");
  if (D.20662 != 0B) goto <D.20663>; else goto <D.20664>;
  <D.20663>:
  D.20665 = strlen (filename);
  D.20666 = D.20665 + 4294967292;
  len = (gint32) D.20666;
  len.107 = (unsigned int) len;
  name = monoeg_malloc (len.107);
  len.108 = (unsigned int) len;
  D.20661 = aname->name;
  strncpy (name, D.20661, len.108);
  goto <D.20669>;
  <D.20664>:
  D.20661 = aname->name;
  name = monoeg_strdup (D.20661);
  <D.20669>:
  D.20670 = aname->culture;
  if (D.20670 != 0B) goto <D.20671>; else goto <D.20672>;
  <D.20671>:
  D.20670 = aname->culture;
  culture = monoeg_g_utf8_strdown (D.20670, -1);
  goto <D.20673>;
  <D.20672>:
  culture = monoeg_strdup ("");
  <D.20673>:
  D.20674 = &aname->public_key_token;
  pubtok = monoeg_g_ascii_strdown (D.20674, 17);
  D.20675 = aname->revision;
  D.20676 = (int) D.20675;
  D.20677 = aname->build;
  D.20678 = (int) D.20677;
  D.20679 = aname->minor;
  D.20680 = (int) D.20679;
  D.20681 = aname->major;
  D.20682 = (int) D.20681;
  version = monoeg_g_strdup_printf ("%d.%d.%d.%d_%s_%s", D.20682, D.20680, D.20678, D.20676, 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.109 = extra_gac_paths;
  if (extra_gac_paths.109 != 0B) goto <D.20684>; else goto <D.20685>;
  <D.20684>:
  paths = extra_gac_paths;
  goto <D.17910>;
  <D.17909>:
  D.20686 = *paths;
  fullpath = monoeg_g_build_path ("/", D.20686, "lib", "mono", "gac", subpath, 0B);
  D.20687 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.20687);
  monoeg_g_free (fullpath);
  paths = paths + 4;
  <D.17910>:
  if (result == 0B) goto <D.20688>; else goto <D.17911>;
  <D.20688>:
  D.20686 = *paths;
  if (D.20686 != 0B) goto <D.17909>; else goto <D.17911>;
  <D.17911>:
  <D.20685>:
  if (result != 0B) goto <D.20689>; else goto <D.20690>;
  <D.20689>:
  result->in_gac = 1;
  monoeg_g_free (subpath);
  D.20660 = result;
  return D.20660;
  <D.20690>:
  D.20691 = mono_assembly_getrootdir ();
  fullpath = monoeg_g_build_path ("/", D.20691, "mono", "gac", subpath, 0B);
  D.20687 = (int) refonly;
  result = mono_assembly_open_full (fullpath, status, D.20687);
  monoeg_g_free (fullpath);
  if (result != 0B) goto <D.20692>; else goto <D.20693>;
  <D.20692>:
  result->in_gac = 1;
  <D.20693>:
  monoeg_g_free (subpath);
  D.20660 = result;
  return D.20660;
}


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

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


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

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


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


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

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


mono_assembly_release_gc_roots (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.20706;
  unsigned char D.20709;
  struct MonoImage * * D.20712;
  unsigned int i.110;
  unsigned int D.20714;
  struct MonoImage * * D.20715;
  struct MonoImage * D.20716;
  unsigned int i.111;
  unsigned int D.20718;

  D.20706 = assembly + 4294967295;
  if (D.20706 > 4294967293B) goto <D.20707>; else goto <D.20708>;
  <D.20707>:
  return;
  <D.20708>:
  D.20709 = assembly->dynamic;
  if (D.20709 != 0) goto <D.20710>; else goto <D.20711>;
  <D.20710>:
  {
    int i;
    struct MonoDynamicImage * dynimg;

    dynimg = assembly->image;
    i = 0;
    goto <D.18007>;
    <D.18006>:
    D.20712 = dynimg->image.modules;
    i.110 = (unsigned int) i;
    D.20714 = i.110 * 4;
    D.20715 = D.20712 + D.20714;
    D.20716 = *D.20715;
    mono_dynamic_image_release_gc_roots (D.20716);
    i = i + 1;
    <D.18007>:
    i.111 = (unsigned int) i;
    D.20718 = dynimg->image.module_count;
    if (i.111 < D.20718) goto <D.18006>; else goto <D.18008>;
    <D.18008>:
    mono_dynamic_image_release_gc_roots (dynimg);
  }
  <D.20711>:
}


mono_assembly_close_except_image_pools (struct MonoAssembly * assembly)
{
  gboolean D.20722;
  int * D.20725;
  int D.20726;
  const char * D.20729;
  struct MonoImage * D.20730;
  _Bool D.20733;
  long int D.20734;
  long int D.20735;
  struct GList * loaded_assemblies.112;
  struct GList * loaded_assemblies.113;
  _Bool D.20742;
  long int D.20743;
  long int D.20744;
  int D.20747;
  struct GSList * D.20750;
  char * D.20751;
  struct GSList * tmp;

  if (assembly == 0B) goto <D.20720>; else goto <D.20721>;
  <D.20720>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "assembly.c", 3029, "assembly != NULL");
  D.20722 = 0;
  return D.20722;
  <D.20721>:
  if (assembly == 4294967295B) goto <D.20723>; else goto <D.20724>;
  <D.20723>:
  D.20722 = 0;
  return D.20722;
  <D.20724>:
  D.20725 = &assembly->ref_count;
  D.20726 = InterlockedDecrement (D.20725);
  if (D.20726 > 0) goto <D.20727>; else goto <D.20728>;
  <D.20727>:
  D.20722 = 0;
  return D.20722;
  <D.20728>:
  mono_profiler_assembly_event (assembly, 2);
  D.20729 = assembly->aname.name;
  mono_trace (64, 1, "Unloading assembly %s [%p].", D.20729, assembly);
  D.20730 = assembly->image;
  mono_debug_close_image (D.20730);
  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20731>; else goto <D.20732>;
    <D.20731>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20732>:
    D.20733 = ret != 0;
    D.20734 = (long int) D.20733;
    D.20735 = __builtin_expect (D.20734, 0);
    if (D.20735 != 0) goto <D.20736>; else goto <D.20737>;
    <D.20736>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3044, "ret == 0");
    <D.20737>:
  }
  loaded_assemblies.112 = loaded_assemblies;
  loaded_assemblies.113 = monoeg_g_list_remove (loaded_assemblies.112, assembly);
  loaded_assemblies = loaded_assemblies.113;
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20740>; else goto <D.20741>;
    <D.20740>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20741>:
    D.20742 = ret != 0;
    D.20743 = (long int) D.20742;
    D.20744 = __builtin_expect (D.20743, 0);
    if (D.20744 != 0) goto <D.20745>; else goto <D.20746>;
    <D.20745>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3046, "ret == 0");
    <D.20746>:
  }
  D.20730 = assembly->image;
  D.20730->assembly = 0B;
  D.20730 = assembly->image;
  D.20747 = mono_image_close_except_pools (D.20730);
  if (D.20747 == 0) goto <D.20748>; else goto <D.20749>;
  <D.20748>:
  assembly->image = 0B;
  <D.20749>:
  tmp = assembly->friend_assembly_names;
  goto <D.18017>;
  <D.18016>:
  {
    struct MonoAssemblyName * fname;

    fname = tmp->data;
    mono_assembly_name_free (fname);
    monoeg_g_free (fname);
  }
  tmp = tmp->next;
  <D.18017>:
  if (tmp != 0B) goto <D.18016>; else goto <D.18018>;
  <D.18018>:
  D.20750 = assembly->friend_assembly_names;
  monoeg_g_slist_free (D.20750);
  D.20751 = assembly->basedir;
  monoeg_g_free (D.20751);
  mono_profiler_assembly_event (assembly, 3);
  D.20722 = 1;
  return D.20722;
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.20753;
  unsigned int D.20754;

  D.20754 = __sync_sub_and_fetch_4 (val, 1);
  D.20753 = (gint32) D.20754;
  return D.20753;
}


mono_assembly_close_finish (struct MonoAssembly * assembly)
{
  struct MonoAssembly * D.20756;
  _Bool D.20757;
  long int D.20758;
  long int D.20759;
  struct MonoImage * D.20762;
  unsigned char D.20765;
  const char * D.20768;

  D.20756 = assembly + 4294967295;
  D.20757 = D.20756 > 4294967293B;
  D.20758 = (long int) D.20757;
  D.20759 = __builtin_expect (D.20758, 0);
  if (D.20759 != 0) goto <D.20760>; else goto <D.20761>;
  <D.20760>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3069, "assembly && assembly != REFERENCE_MISSING");
  <D.20761>:
  D.20762 = assembly->image;
  if (D.20762 != 0B) goto <D.20763>; else goto <D.20764>;
  <D.20763>:
  D.20762 = assembly->image;
  mono_image_close_finish (D.20762);
  <D.20764>:
  D.20765 = assembly->dynamic;
  if (D.20765 != 0) goto <D.20766>; else goto <D.20767>;
  <D.20766>:
  D.20768 = assembly->aname.culture;
  monoeg_g_free (D.20768);
  goto <D.20769>;
  <D.20767>:
  monoeg_g_free (assembly);
  <D.20769>:
}


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

  D.20770 = mono_assembly_close_except_image_pools (assembly);
  if (D.20770 != 0) goto <D.20771>; else goto <D.20772>;
  <D.20771>:
  mono_assembly_close_finish (assembly);
  <D.20772>:
}


mono_assembly_load_module (struct MonoAssembly * assembly, guint32 idx)
{
  struct MonoImage * D.20773;
  int idx.114;
  struct MonoImage * D.20775;

  idx.114 = (int) idx;
  D.20775 = assembly->image;
  D.20773 = mono_image_load_file_for_image (D.20775, idx.114);
  return D.20773;
}


mono_assembly_foreach (void (*GFunc) (void *, void *) func, void * user_data)
{
  _Bool D.20779;
  long int D.20780;
  long int D.20781;
  struct GList * loaded_assemblies.115;
  _Bool D.20787;
  long int D.20788;
  long int D.20789;
  struct GList * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20777>; else goto <D.20778>;
    <D.20777>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20778>:
    D.20779 = ret != 0;
    D.20780 = (long int) D.20779;
    D.20781 = __builtin_expect (D.20780, 0);
    if (D.20781 != 0) goto <D.20782>; else goto <D.20783>;
    <D.20782>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3110, "ret == 0");
    <D.20783>:
  }
  loaded_assemblies.115 = loaded_assemblies;
  copy = monoeg_g_list_copy (loaded_assemblies.115);
  {
    int ret;

    ret = pthread_mutex_unlock (&assemblies_mutex.mutex);
    if (ret != 0) goto <D.20785>; else goto <D.20786>;
    <D.20785>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20786>:
    D.20787 = ret != 0;
    D.20788 = (long int) D.20787;
    D.20789 = __builtin_expect (D.20788, 0);
    if (D.20789 != 0) goto <D.20790>; else goto <D.20791>;
    <D.20790>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "assembly.c", 3112, "ret == 0");
    <D.20791>:
  }
  loaded_assemblies.115 = loaded_assemblies;
  monoeg_g_list_foreach (loaded_assemblies.115, func, user_data);
  monoeg_g_list_free (copy);
}


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

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

    info = l->data;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
  }
  l = l->next;
  <D.18042>:
  if (l != 0B) goto <D.18041>; else goto <D.18043>;
  <D.18043>:
  loaded_assembly_bindings.116 = loaded_assembly_bindings;
  monoeg_g_slist_free (loaded_assembly_bindings.116);
  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.17314>;
  <D.17313>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17314>:
  if (hook != 0B) goto <D.17313>; else goto <D.17315>;
  <D.17315>:
}


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

  hook = assembly_search_hook;
  goto <D.17354>;
  <D.17353>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17354>:
  if (hook != 0B) goto <D.17353>; else goto <D.17355>;
  <D.17355>:
}


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

  hook = assembly_preload_hook;
  goto <D.17409>;
  <D.17408>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17409>:
  if (hook != 0B) goto <D.17408>; else goto <D.17410>;
  <D.17410>:
  hook = assembly_refonly_preload_hook;
  goto <D.17412>;
  <D.17411>:
  next = hook->next;
  monoeg_g_free (hook);
  hook = next;
  <D.17412>:
  if (hook != 0B) goto <D.17411>; else goto <D.17413>;
  <D.17413>:
}


mono_assembly_cleanup_domain_bindings (guint32 domain_id)
{
  int D.20793;
  unsigned int D.20794;
  struct GSList * D.20797;
  struct GSList * D.20799;
  struct GSList * * iter;

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

    l = *iter;
    info = l->data;
    D.20793 = info->domain_id;
    D.20794 = (unsigned int) D.20793;
    if (D.20794 == domain_id) goto <D.20795>; else goto <D.20796>;
    <D.20795>:
    D.20797 = l->next;
    *iter = D.20797;
    mono_assembly_binding_info_free (info);
    monoeg_g_free (info);
    monoeg_g_slist_free_1 (l);
    goto <D.20798>;
    <D.20796>:
    iter = &l->next;
    <D.20798>:
  }
  <D.18051>:
  D.20799 = *iter;
  if (D.20799 != 0B) goto <D.18050>; else goto <D.18052>;
  <D.18052>:
  mono_assembly_binding_unlock ();
}


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


mono_assembly_get_main ()
{
  struct MonoAssembly * D.20800;

  D.20800 = main_assembly;
  return D.20800;
}


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

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


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


mono_assembly_has_skip_verification (struct MonoAssembly * assembly)
{
  <unnamed-unsigned:2> D.20804;
  int D.20805;
  int D.20806;
  gboolean D.20809;
  int D.20810;
  struct MonoImage * D.20811;
  unsigned int D.20812;
  unsigned int D.20813;
  unsigned int D.20816;
  unsigned int D.20819;
  const char * blob.117;
  const char * blob.118;
  unsigned int D.20822;
  sizetype len.119;
  const char * D.20826;
  int D.20827;
  <unnamed-unsigned:24> D.20830;
  int D.20831;
  struct MonoTableInfo * t;
  guint32 cols[3];
  const char * blob;
  int i;
  int len;

  try
    {
      D.20804 = assembly->skipverification;
      D.20805 = (int) D.20804;
      D.20806 = D.20805 & 2;
      if (D.20806 != 0) goto <D.20807>; else goto <D.20808>;
      <D.20807>:
      D.20804 = assembly->skipverification;
      D.20810 = (int) D.20804;
      D.20809 = D.20810 & 1;
      return D.20809;
      <D.20808>:
      D.20811 = assembly->image;
      t = &D.20811->tables[14];
      i = 0;
      goto <D.18108>;
      <D.18107>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.20812 = cols[1];
      D.20813 = D.20812 & 3;
      if (D.20813 != 2) goto <D.20814>; else goto <D.20815>;
      <D.20814>:
      // predicted unlikely by continue predictor.
      goto <D.18106>;
      <D.20815>:
      D.20816 = cols[0];
      if (D.20816 != 8) goto <D.20817>; else goto <D.20818>;
      <D.20817>:
      // predicted unlikely by continue predictor.
      goto <D.18106>;
      <D.20818>:
      D.20819 = cols[2];
      D.20811 = assembly->image;
      blob.117 = mono_metadata_blob_heap (D.20811, D.20819);
      blob = blob.117;
      blob.118 = blob;
      D.20822 = mono_metadata_decode_blob_size (blob.118, &blob);
      len = (int) D.20822;
      if (len == 0) goto <D.20823>; else goto <D.20824>;
      <D.20823>:
      // predicted unlikely by continue predictor.
      goto <D.18106>;
      <D.20824>:
      blob.118 = blob;
      len.119 = (sizetype) len;
      D.20826 = blob.118 + len.119;
      blob.118 = blob;
      D.20827 = mono_assembly_try_decode_skip_verification (blob.118, D.20826);
      if (D.20827 != 0) goto <D.20828>; else goto <D.20829>;
      <D.20828>:
      assembly->skipverification = 3;
      D.20809 = 1;
      return D.20809;
      <D.20829>:
      <D.18106>:
      i = i + 1;
      <D.18108>:
      D.20830 = t->rows;
      D.20831 = (int) D.20830;
      if (D.20831 > i) goto <D.18107>; else goto <D.18109>;
      <D.18109>:
      assembly->skipverification = 2;
      D.20809 = 0;
      return D.20809;
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
    }
}


mono_assembly_try_decode_skip_verification (const char * p, const char * endn)
{
  const char * p.120;
  char D.20835;
  int endn.121;
  int p.122;
  int D.20840;
  char * D.20843;
  _Bool D.20844;
  gboolean D.20845;
  const char * p.123;
  const char * p.124;
  char D.20848;
  unsigned int D.20851;
  unsigned int D.20852;
  int iftmp.125;
  unsigned int len.126;
  int D.20858;
  sizetype len.127;
  const char * p.128;
  unsigned int D.20862;
  sizetype params_len.129;
  unsigned int D.20866;
  int D.20867;
  int abort_decoding.130;
  const char * p.131;
  int i;
  int j;
  int num;
  int len;
  int params_len;

  p.120 = p;
  D.20835 = *p.120;
  if (D.20835 == 60) goto <D.20836>; else goto <D.20837>;
  <D.20836>:
  {
    gsize read;
    gsize written;
    char * res;

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

          D.20843 = strstr (res, "\"SkipVerification\"");
          D.20844 = D.20843 != 0B;
          found = (gboolean) D.20844;
          monoeg_g_free (res);
          D.20845 = found;
          return D.20845;
        }
        <D.20842>:
        D.20845 = 0;
        return D.20845;
      }
    finally
      {
        read = {CLOBBER};
        written = {CLOBBER};
      }
  }
  <D.20837>:
  p.120 = p;
  p.123 = p.120;
  p.124 = p.123 + 1;
  p = p.124;
  D.20848 = *p.123;
  if (D.20848 != 46) goto <D.20849>; else goto <D.20850>;
  <D.20849>:
  D.20845 = 0;
  return D.20845;
  <D.20850>:
  p.120 = p;
  D.20851 = mono_metadata_decode_value (p.120, &p);
  num = (int) D.20851;
  i = 0;
  goto <D.18096>;
  <D.18095>:
  {
    gboolean is_valid;
    gboolean abort_decoding;

    try
      {
        is_valid = 0;
        abort_decoding = 0;
        p.120 = p;
        D.20852 = mono_metadata_decode_value (p.120, &p);
        len = (int) D.20852;
        len.126 = (unsigned int) len;
        if (len.126 > 54) goto <D.20857>; else goto <D.20854>;
        <D.20857>:
        p.120 = p;
        D.20858 = memcmp (p.120, "System.Security.Permissions.SecurityPermissionAttribute", 55);
        if (D.20858 == 0) goto <D.20859>; else goto <D.20854>;
        <D.20859>:
        iftmp.125 = 1;
        goto <D.20855>;
        <D.20854>:
        iftmp.125 = 0;
        <D.20855>:
        is_valid = iftmp.125;
        p.120 = p;
        len.127 = (sizetype) len;
        p.128 = p.120 + len.127;
        p = p.128;
        p.120 = p;
        D.20862 = mono_metadata_decode_value (p.120, &p);
        params_len = (int) D.20862;
        if (is_valid != 0) goto <D.20863>; else goto <D.20864>;
        <D.20863>:
        {
          const char * params_end;

          p.120 = p;
          params_len.129 = (sizetype) params_len;
          params_end = p.120 + params_len.129;
          p.120 = p;
          D.20866 = mono_metadata_decode_value (p.120, &p);
          len = (int) D.20866;
          j = 0;
          goto <D.18094>;
          <D.18093>:
          p.120 = p;
          D.20867 = mono_assembly_try_decode_skip_verification_param (p.120, &p, &abort_decoding);
          if (D.20867 != 0) goto <D.20868>; else goto <D.20869>;
          <D.20868>:
          D.20845 = 1;
          return D.20845;
          <D.20869>:
          abort_decoding.130 = abort_decoding;
          if (abort_decoding.130 != 0) goto <D.18092>; else goto <D.20871>;
          <D.20871>:
          j = j + 1;
          <D.18094>:
          if (j < len) goto <D.18093>; else goto <D.18092>;
          <D.18092>:
          p = params_end;
        }
        goto <D.20872>;
        <D.20864>:
        p.120 = p;
        params_len.129 = (sizetype) params_len;
        p.131 = p.120 + params_len.129;
        p = p.131;
        <D.20872>:
      }
    finally
      {
        abort_decoding = {CLOBBER};
      }
  }
  i = i + 1;
  <D.18096>:
  if (i < num) goto <D.18095>; else goto <D.18097>;
  <D.18097>:
  D.20845 = 0;
  return D.20845;
}


mono_assembly_try_decode_skip_verification_param (const char * p, const char * * resp, gboolean * abort_decoding)
{
  const char * p.132;
  const char * p.133;
  const char * p.134;
  char D.20881;
  int D.20882;
  gboolean D.20883;
  const char * p.135;
  const char * p.136;
  char D.20886;
  unsigned int D.20889;
  unsigned int len.137;
  int D.20893;
  sizetype len.138;
  const char * p.139;
  char D.20898;
  sizetype D.20899;
  const char * p.140;
  int len;

  p.132 = p;
  p.133 = p.132;
  p.134 = p.133 + 1;
  p = p.134;
  D.20881 = *p.133;
  D.20882 = (int) D.20881;
  switch (D.20882) <default: <D.18075>, case 83: <D.18074>, case 84: <D.18072>>
  <D.18072>:
  goto <D.18073>;
  <D.18074>:
  <D.18075>:
  *abort_decoding = 1;
  D.20883 = 0;
  return D.20883;
  <D.18073>:
  p.132 = p;
  p.135 = p.132;
  p.136 = p.135 + 1;
  p = p.136;
  D.20886 = *p.135;
  if (D.20886 != 2) goto <D.20887>; else goto <D.20888>;
  <D.20887>:
  *abort_decoding = 1;
  D.20883 = 0;
  return D.20883;
  <D.20888>:
  p.132 = p;
  D.20889 = mono_metadata_decode_value (p.132, &p);
  len = (int) D.20889;
  len.137 = (unsigned int) len;
  if (len.137 > 15) goto <D.20891>; else goto <D.20892>;
  <D.20891>:
  p.132 = p;
  D.20893 = memcmp (p.132, "SkipVerification", 16);
  if (D.20893 == 0) goto <D.20894>; else goto <D.20895>;
  <D.20894>:
  p.132 = p;
  len.138 = (sizetype) len;
  p.139 = p.132 + len.138;
  p = p.139;
  p.132 = p;
  D.20898 = *p.132;
  D.20883 = (gboolean) D.20898;
  return D.20883;
  <D.20895>:
  <D.20892>:
  p.132 = p;
  len.138 = (sizetype) len;
  D.20899 = len.138 + 1;
  p.140 = p.132 + D.20899;
  p = p.140;
  p.132 = p;
  *resp = p.132;
  D.20883 = 0;
  return D.20883;
}