mono_config_cleanup ()
{
  struct GHashTable * config_handlers.0;
  char * mono_cfg_dir_allocated.1;

  config_handlers.0 = config_handlers;
  if (config_handlers.0 != 0B) goto <D.16284>; else goto <D.16285>;
  <D.16284>:
  config_handlers.0 = config_handlers;
  monoeg_g_hash_table_destroy (config_handlers.0);
  <D.16285>:
  mono_cfg_dir_allocated.1 = mono_cfg_dir_allocated;
  monoeg_g_free (mono_cfg_dir_allocated.1);
}


mono_config_parse_memory (const char * buffer)
{
  unsigned int D.16287;
  struct ParseState state;

  try
    {
      state = {};
      state.user_data = "<buffer>";
      D.16287 = strlen (buffer);
      mono_config_parse_xml_with_context (&state, buffer, D.16287);
    }
  finally
    {
      state = {CLOBBER};
    }
}


mono_config_parse_xml_with_context (struct ParseState * state, const char * text, gsize len)
{
  int inited.2;
  int len.3;
  int D.16292;
  struct GMarkupParseContext * context;

  inited.2 = inited;
  if (inited.2 == 0) goto <D.16289>; else goto <D.16290>;
  <D.16289>:
  mono_config_init ();
  <D.16290>:
  context = monoeg_g_markup_parse_context_new (&mono_parser, 0, state, 0B);
  len.3 = (int) len;
  D.16292 = monoeg_g_markup_parse_context_parse (context, text, len.3, 0B);
  if (D.16292 != 0) goto <D.16293>; else goto <D.16294>;
  <D.16293>:
  monoeg_g_markup_parse_context_end_parse (context, 0B);
  <D.16294>:
  monoeg_g_markup_parse_context_free (context);
}


parse_error (struct GMarkupParseContext * context, struct GError * error, void * user_data)
{
  const gchar * iftmp.4;
  void * D.16299;
  const gchar * iftmp.5;
  gchar * D.16305;
  struct ParseState * state;
  const gchar * msg;
  const gchar * filename;

  state = user_data;
  if (state != 0B) goto <D.16298>; else goto <D.16296>;
  <D.16298>:
  D.16299 = state->user_data;
  if (D.16299 != 0B) goto <D.16300>; else goto <D.16296>;
  <D.16300>:
  iftmp.4 = state->user_data;
  goto <D.16297>;
  <D.16296>:
  iftmp.4 = "<unknown>";
  <D.16297>:
  filename = iftmp.4;
  if (error != 0B) goto <D.16304>; else goto <D.16302>;
  <D.16304>:
  D.16305 = error->message;
  if (D.16305 != 0B) goto <D.16306>; else goto <D.16302>;
  <D.16306>:
  iftmp.5 = error->message;
  goto <D.16303>;
  <D.16302>:
  iftmp.5 = "";
  <D.16303>:
  msg = iftmp.5;
  monoeg_g_log (0B, 16, "Error parsing %s: %s", filename, msg);
}


passthrough (struct GMarkupParseContext * context, const gchar * text, gsize text_len, void * user_data, struct GError * * error)
{

}


parse_text (struct GMarkupParseContext * context, const gchar * text, gsize text_len, void * user_data, struct GError * * error)
{
  struct MonoParseHandler * D.16307;
  void (*<T27f1>) (void *, const char *, gsize) D.16310;
  void * D.16313;
  struct ParseState * state;

  state = user_data;
  D.16307 = state->current;
  if (D.16307 != 0B) goto <D.16308>; else goto <D.16309>;
  <D.16308>:
  D.16307 = state->current;
  D.16310 = D.16307->text;
  if (D.16310 != 0B) goto <D.16311>; else goto <D.16312>;
  <D.16311>:
  D.16307 = state->current;
  D.16310 = D.16307->text;
  D.16313 = state->user_data;
  D.16310 (D.16313, text, text_len);
  <D.16312>:
  <D.16309>:
}


end_element (struct GMarkupParseContext * context, const gchar * element_name, void * user_data, struct GError * * error)
{
  struct MonoParseHandler * D.16314;
  void (*<T27f5>) (void *, const char *) D.16317;
  void * D.16320;
  int D.15794;
  const char * D.16321;
  void (*<Tb30>) (void *) D.16324;
  struct ParseState * state;

  state = user_data;
  D.16314 = state->current;
  if (D.16314 != 0B) goto <D.16315>; else goto <D.16316>;
  <D.16315>:
  D.16314 = state->current;
  D.16317 = D.16314->end;
  if (D.16317 != 0B) goto <D.16318>; else goto <D.16319>;
  <D.16318>:
  D.16314 = state->current;
  D.16317 = D.16314->end;
  D.16320 = state->user_data;
  D.16317 (D.16320, element_name);
  <D.16319>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16314 = state->current;
    D.16321 = D.16314->element_name;
    D.15794 = __builtin_strcmp (D.16321, element_name);
  }
  if (D.15794 == 0) goto <D.16322>; else goto <D.16323>;
  <D.16322>:
  D.16314 = state->current;
  D.16324 = D.16314->finish;
  if (D.16324 != 0B) goto <D.16325>; else goto <D.16326>;
  <D.16325>:
  D.16314 = state->current;
  D.16324 = D.16314->finish;
  D.16320 = state->user_data;
  D.16324 (D.16320);
  <D.16326>:
  state->current = 0B;
  state->user_data = 0B;
  <D.16323>:
  <D.16316>:
}


start_element (struct GMarkupParseContext * context, const gchar * element_name, const gchar * * attribute_names, const gchar * * attribute_values, void * user_data, struct GError * * error)
{
  struct MonoParseHandler * D.16327;
  struct GHashTable * config_handlers.6;
  void * D.16331;
  void * (*<T27e9>) (struct MonoImage *) D.16334;
  struct MonoImage * D.16337;
  void * D.16338;
  void (*<T27ed>) (void *, const gchar *, const gchar * *, const gchar * *) D.16341;
  void * D.16344;
  struct ParseState * state;

  state = user_data;
  D.16327 = state->current;
  if (D.16327 == 0B) goto <D.16328>; else goto <D.16329>;
  <D.16328>:
  config_handlers.6 = config_handlers;
  D.16331 = monoeg_g_hash_table_lookup (config_handlers.6, element_name);
  state->current = D.16331;
  D.16327 = state->current;
  if (D.16327 != 0B) goto <D.16332>; else goto <D.16333>;
  <D.16332>:
  D.16327 = state->current;
  D.16334 = D.16327->init;
  if (D.16334 != 0B) goto <D.16335>; else goto <D.16336>;
  <D.16335>:
  D.16327 = state->current;
  D.16334 = D.16327->init;
  D.16337 = state->assembly;
  D.16338 = D.16334 (D.16337);
  state->user_data = D.16338;
  <D.16336>:
  <D.16333>:
  <D.16329>:
  D.16327 = state->current;
  if (D.16327 != 0B) goto <D.16339>; else goto <D.16340>;
  <D.16339>:
  D.16327 = state->current;
  D.16341 = D.16327->start;
  if (D.16341 != 0B) goto <D.16342>; else goto <D.16343>;
  <D.16342>:
  D.16327 = state->current;
  D.16341 = D.16327->start;
  D.16344 = state->user_data;
  D.16341 (D.16344, element_name, attribute_names, attribute_values);
  <D.16343>:
  <D.16340>:
}


mono_config_init ()
{
  struct GHashTable * config_handlers.7;
  struct GHashTable * config_handlers.8;
  const char * D.16347;
  const char * D.16348;

  inited = 1;
  config_handlers.7 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  config_handlers = config_handlers.7;
  config_handlers.8 = config_handlers;
  D.16347 = "dllmap";
  monoeg_g_hash_table_insert_replace (config_handlers.8, D.16347, &dllmap_handler, 0);
  config_handlers.8 = config_handlers;
  D.16348 = "legacyUnhandledExceptionPolicy";
  monoeg_g_hash_table_insert_replace (config_handlers.8, D.16348, &legacyUEP_handler, 0);
}


legacyUEP_start (void * user_data, const gchar * element_name, const gchar * * attribute_names, const gchar * * attribute_values)
{
  int D.16001;
  int iftmp.9;
  int D.16000;
  const char[31] * D.16352;
  unsigned char D.16353;
  int D.16354;
  unsigned char D.16355;
  int D.16356;
  const unsigned char * D.16361;
  unsigned char D.16362;
  int D.16363;
  const unsigned char * D.16364;
  unsigned char D.16365;
  int D.16366;
  const unsigned char * D.16371;
  unsigned char D.16372;
  int D.16373;
  const unsigned char * D.16374;
  unsigned char D.16375;
  int D.16376;
  const unsigned char * D.16381;
  unsigned char D.16382;
  int D.16383;
  const unsigned char * D.16384;
  unsigned char D.16385;
  int D.16386;
  const gchar * D.16390;
  int D.16010;
  int iftmp.10;
  int D.16009;
  const char[8] * D.16396;
  unsigned char D.16397;
  int D.16398;
  unsigned char D.16399;
  int D.16400;
  const unsigned char * D.16405;
  unsigned char D.16406;
  int D.16407;
  const unsigned char * D.16408;
  unsigned char D.16409;
  int D.16410;
  const unsigned char * D.16415;
  unsigned char D.16416;
  int D.16417;
  const unsigned char * D.16418;
  unsigned char D.16419;
  int D.16420;
  const unsigned char * D.16425;
  unsigned char D.16426;
  int D.16427;
  const unsigned char * D.16428;
  unsigned char D.16429;
  int D.16430;
  int D.16019;
  int iftmp.11;
  int D.16018;
  const char[2] * D.16439;
  unsigned char D.16440;
  int D.16441;
  unsigned char D.16442;
  int D.16443;
  const unsigned char * D.16448;
  unsigned char D.16449;
  int D.16450;
  const unsigned char * D.16451;
  unsigned char D.16452;
  int D.16453;
  const unsigned char * D.16458;
  unsigned char D.16459;
  int D.16460;
  const unsigned char * D.16461;
  unsigned char D.16462;
  int D.16463;
  const unsigned char * D.16468;
  unsigned char D.16469;
  int D.16470;
  const unsigned char * D.16471;
  unsigned char D.16472;
  int D.16473;
  const gchar * D.16475;
  int D.16477;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.16352 = "legacyUnhandledExceptionPolicy";
      D.16353 = MEM[(const unsigned char *)D.16352];
      D.16354 = (int) D.16353;
      D.16355 = *__s2;
      D.16356 = (int) D.16355;
      __result = D.16354 - D.16356;
      {
        if (__s2_len != 0) goto <D.16357>; else goto <D.16358>;
        <D.16357>:
        if (__result == 0) goto <D.16359>; else goto <D.16360>;
        <D.16359>:
        D.16361 = &MEM[(void *)"legacyUnhandledExceptionPolicy" + 1B];
        D.16362 = *D.16361;
        D.16363 = (int) D.16362;
        D.16364 = __s2 + 1;
        D.16365 = *D.16364;
        D.16366 = (int) D.16365;
        __result = D.16363 - D.16366;
        if (__s2_len > 1) goto <D.16367>; else goto <D.16368>;
        <D.16367>:
        if (__result == 0) goto <D.16369>; else goto <D.16370>;
        <D.16369>:
        D.16371 = &MEM[(void *)"legacyUnhandledExceptionPolicy" + 2B];
        D.16372 = *D.16371;
        D.16373 = (int) D.16372;
        D.16374 = __s2 + 2;
        D.16375 = *D.16374;
        D.16376 = (int) D.16375;
        __result = D.16373 - D.16376;
        if (__s2_len > 2) goto <D.16377>; else goto <D.16378>;
        <D.16377>:
        if (__result == 0) goto <D.16379>; else goto <D.16380>;
        <D.16379>:
        D.16381 = &MEM[(void *)"legacyUnhandledExceptionPolicy" + 3B];
        D.16382 = *D.16381;
        D.16383 = (int) D.16382;
        D.16384 = __s2 + 3;
        D.16385 = *D.16384;
        D.16386 = (int) D.16385;
        __result = D.16383 - D.16386;
        <D.16380>:
        <D.16378>:
        <D.16370>:
        <D.16368>:
        <D.16360>:
        <D.16358>:
      }
      D.16000 = __result;
    }
    iftmp.9 = -D.16000;
    goto <D.16387>;
    <D.16351>:
    iftmp.9 = __builtin_strcmp (element_name, "legacyUnhandledExceptionPolicy");
    <D.16387>:
    D.16001 = iftmp.9;
  }
  if (D.16001 == 0) goto <D.16388>; else goto <D.16389>;
  <D.16388>:
  D.16390 = *attribute_names;
  if (D.16390 != 0B) goto <D.16391>; else goto <D.16392>;
  <D.16391>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *attribute_names;
      D.16396 = "enabled";
      D.16397 = MEM[(const unsigned char *)D.16396];
      D.16398 = (int) D.16397;
      D.16399 = *__s2;
      D.16400 = (int) D.16399;
      __result = D.16398 - D.16400;
      {
        if (__s2_len != 0) goto <D.16401>; else goto <D.16402>;
        <D.16401>:
        if (__result == 0) goto <D.16403>; else goto <D.16404>;
        <D.16403>:
        D.16405 = &MEM[(void *)"enabled" + 1B];
        D.16406 = *D.16405;
        D.16407 = (int) D.16406;
        D.16408 = __s2 + 1;
        D.16409 = *D.16408;
        D.16410 = (int) D.16409;
        __result = D.16407 - D.16410;
        if (__s2_len > 1) goto <D.16411>; else goto <D.16412>;
        <D.16411>:
        if (__result == 0) goto <D.16413>; else goto <D.16414>;
        <D.16413>:
        D.16415 = &MEM[(void *)"enabled" + 2B];
        D.16416 = *D.16415;
        D.16417 = (int) D.16416;
        D.16418 = __s2 + 2;
        D.16419 = *D.16418;
        D.16420 = (int) D.16419;
        __result = D.16417 - D.16420;
        if (__s2_len > 2) goto <D.16421>; else goto <D.16422>;
        <D.16421>:
        if (__result == 0) goto <D.16423>; else goto <D.16424>;
        <D.16423>:
        D.16425 = &MEM[(void *)"enabled" + 3B];
        D.16426 = *D.16425;
        D.16427 = (int) D.16426;
        D.16428 = __s2 + 3;
        D.16429 = *D.16428;
        D.16430 = (int) D.16429;
        __result = D.16427 - D.16430;
        <D.16424>:
        <D.16422>:
        <D.16414>:
        <D.16412>:
        <D.16404>:
        <D.16402>:
      }
      D.16009 = __result;
    }
    iftmp.10 = -D.16009;
    goto <D.16431>;
    <D.16395>:
    D.16390 = *attribute_names;
    iftmp.10 = __builtin_strcmp (D.16390, "enabled");
    <D.16431>:
    D.16010 = iftmp.10;
  }
  if (D.16010 == 0) goto <D.16432>; else goto <D.16433>;
  <D.16432>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *attribute_values;
      D.16439 = "1";
      D.16440 = MEM[(const unsigned char *)D.16439];
      D.16441 = (int) D.16440;
      D.16442 = *__s2;
      D.16443 = (int) D.16442;
      __result = D.16441 - D.16443;
      {
        if (__s2_len != 0) goto <D.16444>; else goto <D.16445>;
        <D.16444>:
        if (__result == 0) goto <D.16446>; else goto <D.16447>;
        <D.16446>:
        D.16448 = &MEM[(void *)"1" + 1B];
        D.16449 = *D.16448;
        D.16450 = (int) D.16449;
        D.16451 = __s2 + 1;
        D.16452 = *D.16451;
        D.16453 = (int) D.16452;
        __result = D.16450 - D.16453;
        if (__s2_len > 1) goto <D.16454>; else goto <D.16455>;
        <D.16454>:
        if (__result == 0) goto <D.16456>; else goto <D.16457>;
        <D.16456>:
        D.16458 = &MEM[(void *)"1" + 2B];
        D.16459 = *D.16458;
        D.16460 = (int) D.16459;
        D.16461 = __s2 + 2;
        D.16462 = *D.16461;
        D.16463 = (int) D.16462;
        __result = D.16460 - D.16463;
        if (__s2_len > 2) goto <D.16464>; else goto <D.16465>;
        <D.16464>:
        if (__result == 0) goto <D.16466>; else goto <D.16467>;
        <D.16466>:
        D.16468 = &MEM[(void *)"1" + 3B];
        D.16469 = *D.16468;
        D.16470 = (int) D.16469;
        D.16471 = __s2 + 3;
        D.16472 = *D.16471;
        D.16473 = (int) D.16472;
        __result = D.16470 - D.16473;
        <D.16467>:
        <D.16465>:
        <D.16457>:
        <D.16455>:
        <D.16447>:
        <D.16445>:
      }
      D.16018 = __result;
    }
    iftmp.11 = -D.16018;
    goto <D.16474>;
    <D.16438>:
    D.16475 = *attribute_values;
    iftmp.11 = __builtin_strcmp (D.16475, "1");
    <D.16474>:
    D.16019 = iftmp.11;
  }
  if (D.16019 == 0) goto <D.16434>; else goto <D.16476>;
  <D.16476>:
  D.16475 = *attribute_values;
  D.16477 = monoeg_ascii_strcasecmp (D.16475, "true");
  if (D.16477 == 0) goto <D.16434>; else goto <D.16435>;
  <D.16434>:
  mono_runtime_unhandled_exception_policy_set (0);
  <D.16435>:
  <D.16433>:
  <D.16392>:
  <D.16389>:
}


dllmap_finish (void * user_data)
{
  char * D.16478;
  char * D.16479;
  struct DllInfo * info;

  info = user_data;
  D.16478 = info->dll;
  monoeg_g_free (D.16478);
  D.16479 = info->target;
  monoeg_g_free (D.16479);
  monoeg_g_free (info);
}


dllmap_start (void * user_data, const gchar * element_name, const gchar * * attribute_names, const gchar * * attribute_values)
{
  int D.15863;
  int iftmp.12;
  int D.15862;
  const char[7] * D.16483;
  unsigned char D.16484;
  int D.16485;
  unsigned char D.16486;
  int D.16487;
  const unsigned char * D.16492;
  unsigned char D.16493;
  int D.16494;
  const unsigned char * D.16495;
  unsigned char D.16496;
  int D.16497;
  const unsigned char * D.16502;
  unsigned char D.16503;
  int D.16504;
  const unsigned char * D.16505;
  unsigned char D.16506;
  int D.16507;
  const unsigned char * D.16512;
  unsigned char D.16513;
  int D.16514;
  const unsigned char * D.16515;
  unsigned char D.16516;
  int D.16517;
  char * D.16521;
  char * D.16522;
  int D.15872;
  int iftmp.13;
  int D.15871;
  unsigned int i.14;
  unsigned int D.16527;
  const gchar * * D.16528;
  const char[4] * D.16529;
  unsigned char D.16530;
  int D.16531;
  unsigned char D.16532;
  int D.16533;
  const unsigned char * D.16538;
  unsigned char D.16539;
  int D.16540;
  const unsigned char * D.16541;
  unsigned char D.16542;
  int D.16543;
  const unsigned char * D.16548;
  unsigned char D.16549;
  int D.16550;
  const unsigned char * D.16551;
  unsigned char D.16552;
  int D.16553;
  const unsigned char * D.16558;
  unsigned char D.16559;
  int D.16560;
  const unsigned char * D.16561;
  unsigned char D.16562;
  int D.16563;
  const gchar * D.16565;
  const gchar * * D.16568;
  const gchar * D.16569;
  gchar * D.16570;
  int D.15881;
  int iftmp.15;
  int D.15880;
  const char[7] * D.16575;
  unsigned char D.16576;
  int D.16577;
  unsigned char D.16578;
  int D.16579;
  const unsigned char * D.16584;
  unsigned char D.16585;
  int D.16586;
  const unsigned char * D.16587;
  unsigned char D.16588;
  int D.16589;
  const unsigned char * D.16594;
  unsigned char D.16595;
  int D.16596;
  const unsigned char * D.16597;
  unsigned char D.16598;
  int D.16599;
  const unsigned char * D.16604;
  unsigned char D.16605;
  int D.16606;
  const unsigned char * D.16607;
  unsigned char D.16608;
  int D.16609;
  gchar * D.16613;
  int D.15890;
  int iftmp.16;
  int D.15889;
  const char[3] * D.16620;
  unsigned char D.16621;
  int D.16622;
  unsigned char D.16623;
  int D.16624;
  const unsigned char * D.16629;
  unsigned char D.16630;
  int D.16631;
  const unsigned char * D.16632;
  unsigned char D.16633;
  int D.16634;
  const unsigned char * D.16639;
  unsigned char D.16640;
  int D.16641;
  const unsigned char * D.16642;
  unsigned char D.16643;
  int D.16644;
  const unsigned char * D.16649;
  unsigned char D.16650;
  int D.16651;
  const unsigned char * D.16652;
  unsigned char D.16653;
  int D.16654;
  int D.16657;
  int D.15899;
  int iftmp.17;
  int D.15898;
  const char[4] * D.16664;
  unsigned char D.16665;
  int D.16666;
  unsigned char D.16667;
  int D.16668;
  const unsigned char * D.16673;
  unsigned char D.16674;
  int D.16675;
  const unsigned char * D.16676;
  unsigned char D.16677;
  int D.16678;
  const unsigned char * D.16683;
  unsigned char D.16684;
  int D.16685;
  const unsigned char * D.16686;
  unsigned char D.16687;
  int D.16688;
  const unsigned char * D.16693;
  unsigned char D.16694;
  int D.16695;
  const unsigned char * D.16696;
  unsigned char D.16697;
  int D.16698;
  int D.16701;
  int D.15908;
  int iftmp.18;
  int D.15907;
  const char[9] * D.16706;
  unsigned char D.16707;
  int D.16708;
  unsigned char D.16709;
  int D.16710;
  const unsigned char * D.16715;
  unsigned char D.16716;
  int D.16717;
  const unsigned char * D.16718;
  unsigned char D.16719;
  int D.16720;
  const unsigned char * D.16725;
  unsigned char D.16726;
  int D.16727;
  const unsigned char * D.16728;
  unsigned char D.16729;
  int D.16730;
  const unsigned char * D.16735;
  unsigned char D.16736;
  int D.16737;
  const unsigned char * D.16738;
  unsigned char D.16739;
  int D.16740;
  int D.16744;
  int D.16747;
  struct MonoImage * D.16750;
  int D.15920;
  int iftmp.19;
  int D.15919;
  const char[9] * D.16755;
  unsigned char D.16756;
  int D.16757;
  unsigned char D.16758;
  int D.16759;
  const unsigned char * D.16764;
  unsigned char D.16765;
  int D.16766;
  const unsigned char * D.16767;
  unsigned char D.16768;
  int D.16769;
  const unsigned char * D.16774;
  unsigned char D.16775;
  int D.16776;
  const unsigned char * D.16777;
  unsigned char D.16778;
  int D.16779;
  const unsigned char * D.16784;
  unsigned char D.16785;
  int D.16786;
  const unsigned char * D.16787;
  unsigned char D.16788;
  int D.16789;
  int D.15933;
  int iftmp.20;
  int D.15932;
  unsigned char D.16796;
  int D.16797;
  const unsigned char * D.16802;
  unsigned char D.16803;
  int D.16804;
  const unsigned char * D.16809;
  unsigned char D.16810;
  int D.16811;
  const unsigned char * D.16816;
  unsigned char D.16817;
  int D.16818;
  int D.15942;
  int iftmp.21;
  int D.15941;
  unsigned char D.16826;
  int D.16827;
  const unsigned char * D.16832;
  unsigned char D.16833;
  int D.16834;
  const unsigned char * D.16839;
  unsigned char D.16840;
  int D.16841;
  const unsigned char * D.16846;
  unsigned char D.16847;
  int D.16848;
  int D.15951;
  int iftmp.22;
  int D.15950;
  const char[5] * D.16856;
  unsigned char D.16857;
  int D.16858;
  unsigned char D.16859;
  int D.16860;
  const unsigned char * D.16865;
  unsigned char D.16866;
  int D.16867;
  const unsigned char * D.16868;
  unsigned char D.16869;
  int D.16870;
  const unsigned char * D.16875;
  unsigned char D.16876;
  int D.16877;
  const unsigned char * D.16878;
  unsigned char D.16879;
  int D.16880;
  const unsigned char * D.16885;
  unsigned char D.16886;
  int D.16887;
  const unsigned char * D.16888;
  unsigned char D.16889;
  int D.16890;
  int D.15960;
  int iftmp.23;
  int D.15959;
  unsigned char D.16900;
  int D.16901;
  const unsigned char * D.16906;
  unsigned char D.16907;
  int D.16908;
  const unsigned char * D.16913;
  unsigned char D.16914;
  int D.16915;
  const unsigned char * D.16920;
  unsigned char D.16921;
  int D.16922;
  int D.16925;
  int D.15969;
  int iftmp.24;
  int D.15968;
  unsigned char D.16932;
  int D.16933;
  const unsigned char * D.16938;
  unsigned char D.16939;
  int D.16940;
  const unsigned char * D.16945;
  unsigned char D.16946;
  int D.16947;
  const unsigned char * D.16952;
  unsigned char D.16953;
  int D.16954;
  int D.16957;
  int D.15978;
  int iftmp.25;
  int D.15977;
  unsigned char D.16962;
  int D.16963;
  const unsigned char * D.16968;
  unsigned char D.16969;
  int D.16970;
  const unsigned char * D.16975;
  unsigned char D.16976;
  int D.16977;
  const unsigned char * D.16982;
  unsigned char D.16983;
  int D.16984;
  int D.16988;
  int i;
  struct DllInfo * info;

  info = user_data;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.16483 = "dllmap";
      D.16484 = MEM[(const unsigned char *)D.16483];
      D.16485 = (int) D.16484;
      D.16486 = *__s2;
      D.16487 = (int) D.16486;
      __result = D.16485 - D.16487;
      {
        if (__s2_len != 0) goto <D.16488>; else goto <D.16489>;
        <D.16488>:
        if (__result == 0) goto <D.16490>; else goto <D.16491>;
        <D.16490>:
        D.16492 = &MEM[(void *)"dllmap" + 1B];
        D.16493 = *D.16492;
        D.16494 = (int) D.16493;
        D.16495 = __s2 + 1;
        D.16496 = *D.16495;
        D.16497 = (int) D.16496;
        __result = D.16494 - D.16497;
        if (__s2_len > 1) goto <D.16498>; else goto <D.16499>;
        <D.16498>:
        if (__result == 0) goto <D.16500>; else goto <D.16501>;
        <D.16500>:
        D.16502 = &MEM[(void *)"dllmap" + 2B];
        D.16503 = *D.16502;
        D.16504 = (int) D.16503;
        D.16505 = __s2 + 2;
        D.16506 = *D.16505;
        D.16507 = (int) D.16506;
        __result = D.16504 - D.16507;
        if (__s2_len > 2) goto <D.16508>; else goto <D.16509>;
        <D.16508>:
        if (__result == 0) goto <D.16510>; else goto <D.16511>;
        <D.16510>:
        D.16512 = &MEM[(void *)"dllmap" + 3B];
        D.16513 = *D.16512;
        D.16514 = (int) D.16513;
        D.16515 = __s2 + 3;
        D.16516 = *D.16515;
        D.16517 = (int) D.16516;
        __result = D.16514 - D.16517;
        <D.16511>:
        <D.16509>:
        <D.16501>:
        <D.16499>:
        <D.16491>:
        <D.16489>:
      }
      D.15862 = __result;
    }
    iftmp.12 = -D.15862;
    goto <D.16518>;
    <D.16482>:
    iftmp.12 = __builtin_strcmp (element_name, "dllmap");
    <D.16518>:
    D.15863 = iftmp.12;
  }
  if (D.15863 == 0) goto <D.16519>; else goto <D.16520>;
  <D.16519>:
  D.16521 = info->dll;
  monoeg_g_free (D.16521);
  D.16522 = info->target;
  monoeg_g_free (D.16522);
  info->target = 0B;
  D.16522 = info->target;
  info->dll = D.16522;
  info->ignore = 0;
  i = 0;
  goto <D.15910>;
  <D.15909>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      __s2 = *D.16528;
      D.16529 = "dll";
      D.16530 = MEM[(const unsigned char *)D.16529];
      D.16531 = (int) D.16530;
      D.16532 = *__s2;
      D.16533 = (int) D.16532;
      __result = D.16531 - D.16533;
      {
        if (__s2_len != 0) goto <D.16534>; else goto <D.16535>;
        <D.16534>:
        if (__result == 0) goto <D.16536>; else goto <D.16537>;
        <D.16536>:
        D.16538 = &MEM[(void *)"dll" + 1B];
        D.16539 = *D.16538;
        D.16540 = (int) D.16539;
        D.16541 = __s2 + 1;
        D.16542 = *D.16541;
        D.16543 = (int) D.16542;
        __result = D.16540 - D.16543;
        if (__s2_len > 1) goto <D.16544>; else goto <D.16545>;
        <D.16544>:
        if (__result == 0) goto <D.16546>; else goto <D.16547>;
        <D.16546>:
        D.16548 = &MEM[(void *)"dll" + 2B];
        D.16549 = *D.16548;
        D.16550 = (int) D.16549;
        D.16551 = __s2 + 2;
        D.16552 = *D.16551;
        D.16553 = (int) D.16552;
        __result = D.16550 - D.16553;
        if (__s2_len > 2) goto <D.16554>; else goto <D.16555>;
        <D.16554>:
        if (__result == 0) goto <D.16556>; else goto <D.16557>;
        <D.16556>:
        D.16558 = &MEM[(void *)"dll" + 3B];
        D.16559 = *D.16558;
        D.16560 = (int) D.16559;
        D.16561 = __s2 + 3;
        D.16562 = *D.16561;
        D.16563 = (int) D.16562;
        __result = D.16560 - D.16563;
        <D.16557>:
        <D.16555>:
        <D.16547>:
        <D.16545>:
        <D.16537>:
        <D.16535>:
      }
      D.15871 = __result;
    }
    iftmp.13 = -D.15871;
    goto <D.16564>;
    <D.16525>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16528 = attribute_names + D.16527;
    D.16565 = *D.16528;
    iftmp.13 = __builtin_strcmp (D.16565, "dll");
    <D.16564>:
    D.15872 = iftmp.13;
  }
  if (D.15872 == 0) goto <D.16566>; else goto <D.16567>;
  <D.16566>:
  i.14 = (unsigned int) i;
  D.16527 = i.14 * 4;
  D.16568 = attribute_values + D.16527;
  D.16569 = *D.16568;
  D.16570 = monoeg_strdup (D.16569);
  info->dll = D.16570;
  goto <D.16571>;
  <D.16567>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      __s2 = *D.16528;
      D.16575 = "target";
      D.16576 = MEM[(const unsigned char *)D.16575];
      D.16577 = (int) D.16576;
      D.16578 = *__s2;
      D.16579 = (int) D.16578;
      __result = D.16577 - D.16579;
      {
        if (__s2_len != 0) goto <D.16580>; else goto <D.16581>;
        <D.16580>:
        if (__result == 0) goto <D.16582>; else goto <D.16583>;
        <D.16582>:
        D.16584 = &MEM[(void *)"target" + 1B];
        D.16585 = *D.16584;
        D.16586 = (int) D.16585;
        D.16587 = __s2 + 1;
        D.16588 = *D.16587;
        D.16589 = (int) D.16588;
        __result = D.16586 - D.16589;
        if (__s2_len > 1) goto <D.16590>; else goto <D.16591>;
        <D.16590>:
        if (__result == 0) goto <D.16592>; else goto <D.16593>;
        <D.16592>:
        D.16594 = &MEM[(void *)"target" + 2B];
        D.16595 = *D.16594;
        D.16596 = (int) D.16595;
        D.16597 = __s2 + 2;
        D.16598 = *D.16597;
        D.16599 = (int) D.16598;
        __result = D.16596 - D.16599;
        if (__s2_len > 2) goto <D.16600>; else goto <D.16601>;
        <D.16600>:
        if (__result == 0) goto <D.16602>; else goto <D.16603>;
        <D.16602>:
        D.16604 = &MEM[(void *)"target" + 3B];
        D.16605 = *D.16604;
        D.16606 = (int) D.16605;
        D.16607 = __s2 + 3;
        D.16608 = *D.16607;
        D.16609 = (int) D.16608;
        __result = D.16606 - D.16609;
        <D.16603>:
        <D.16601>:
        <D.16593>:
        <D.16591>:
        <D.16583>:
        <D.16581>:
      }
      D.15880 = __result;
    }
    iftmp.15 = -D.15880;
    goto <D.16610>;
    <D.16574>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16528 = attribute_names + D.16527;
    D.16565 = *D.16528;
    iftmp.15 = __builtin_strcmp (D.16565, "target");
    <D.16610>:
    D.15881 = iftmp.15;
  }
  if (D.15881 == 0) goto <D.16611>; else goto <D.16612>;
  <D.16611>:
  i.14 = (unsigned int) i;
  D.16527 = i.14 * 4;
  D.16568 = attribute_values + D.16527;
  D.16569 = *D.16568;
  D.16613 = monoeg_strdup (D.16569);
  info->target = D.16613;
  goto <D.16614>;
  <D.16612>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      __s2 = *D.16528;
      D.16620 = "os";
      D.16621 = MEM[(const unsigned char *)D.16620];
      D.16622 = (int) D.16621;
      D.16623 = *__s2;
      D.16624 = (int) D.16623;
      __result = D.16622 - D.16624;
      {
        if (__s2_len != 0) goto <D.16625>; else goto <D.16626>;
        <D.16625>:
        if (__result == 0) goto <D.16627>; else goto <D.16628>;
        <D.16627>:
        D.16629 = &MEM[(void *)"os" + 1B];
        D.16630 = *D.16629;
        D.16631 = (int) D.16630;
        D.16632 = __s2 + 1;
        D.16633 = *D.16632;
        D.16634 = (int) D.16633;
        __result = D.16631 - D.16634;
        if (__s2_len > 1) goto <D.16635>; else goto <D.16636>;
        <D.16635>:
        if (__result == 0) goto <D.16637>; else goto <D.16638>;
        <D.16637>:
        D.16639 = &MEM[(void *)"os" + 2B];
        D.16640 = *D.16639;
        D.16641 = (int) D.16640;
        D.16642 = __s2 + 2;
        D.16643 = *D.16642;
        D.16644 = (int) D.16643;
        __result = D.16641 - D.16644;
        if (__s2_len > 2) goto <D.16645>; else goto <D.16646>;
        <D.16645>:
        if (__result == 0) goto <D.16647>; else goto <D.16648>;
        <D.16647>:
        D.16649 = &MEM[(void *)"os" + 3B];
        D.16650 = *D.16649;
        D.16651 = (int) D.16650;
        D.16652 = __s2 + 3;
        D.16653 = *D.16652;
        D.16654 = (int) D.16653;
        __result = D.16651 - D.16654;
        <D.16648>:
        <D.16646>:
        <D.16638>:
        <D.16636>:
        <D.16628>:
        <D.16626>:
      }
      D.15889 = __result;
    }
    iftmp.16 = -D.15889;
    goto <D.16655>;
    <D.16619>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16528 = attribute_names + D.16527;
    D.16565 = *D.16528;
    iftmp.16 = __builtin_strcmp (D.16565, "os");
    <D.16655>:
    D.15890 = iftmp.16;
  }
  if (D.15890 == 0) goto <D.16656>; else goto <D.16615>;
  <D.16656>:
  i.14 = (unsigned int) i;
  D.16527 = i.14 * 4;
  D.16568 = attribute_values + D.16527;
  D.16569 = *D.16568;
  D.16657 = arch_matches ("linux", D.16569);
  if (D.16657 == 0) goto <D.16658>; else goto <D.16615>;
  <D.16658>:
  info->ignore = 1;
  goto <D.16616>;
  <D.16615>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      __s2 = *D.16528;
      D.16664 = "cpu";
      D.16665 = MEM[(const unsigned char *)D.16664];
      D.16666 = (int) D.16665;
      D.16667 = *__s2;
      D.16668 = (int) D.16667;
      __result = D.16666 - D.16668;
      {
        if (__s2_len != 0) goto <D.16669>; else goto <D.16670>;
        <D.16669>:
        if (__result == 0) goto <D.16671>; else goto <D.16672>;
        <D.16671>:
        D.16673 = &MEM[(void *)"cpu" + 1B];
        D.16674 = *D.16673;
        D.16675 = (int) D.16674;
        D.16676 = __s2 + 1;
        D.16677 = *D.16676;
        D.16678 = (int) D.16677;
        __result = D.16675 - D.16678;
        if (__s2_len > 1) goto <D.16679>; else goto <D.16680>;
        <D.16679>:
        if (__result == 0) goto <D.16681>; else goto <D.16682>;
        <D.16681>:
        D.16683 = &MEM[(void *)"cpu" + 2B];
        D.16684 = *D.16683;
        D.16685 = (int) D.16684;
        D.16686 = __s2 + 2;
        D.16687 = *D.16686;
        D.16688 = (int) D.16687;
        __result = D.16685 - D.16688;
        if (__s2_len > 2) goto <D.16689>; else goto <D.16690>;
        <D.16689>:
        if (__result == 0) goto <D.16691>; else goto <D.16692>;
        <D.16691>:
        D.16693 = &MEM[(void *)"cpu" + 3B];
        D.16694 = *D.16693;
        D.16695 = (int) D.16694;
        D.16696 = __s2 + 3;
        D.16697 = *D.16696;
        D.16698 = (int) D.16697;
        __result = D.16695 - D.16698;
        <D.16692>:
        <D.16690>:
        <D.16682>:
        <D.16680>:
        <D.16672>:
        <D.16670>:
      }
      D.15898 = __result;
    }
    iftmp.17 = -D.15898;
    goto <D.16699>;
    <D.16663>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16528 = attribute_names + D.16527;
    D.16565 = *D.16528;
    iftmp.17 = __builtin_strcmp (D.16565, "cpu");
    <D.16699>:
    D.15899 = iftmp.17;
  }
  if (D.15899 == 0) goto <D.16700>; else goto <D.16659>;
  <D.16700>:
  i.14 = (unsigned int) i;
  D.16527 = i.14 * 4;
  D.16568 = attribute_values + D.16527;
  D.16569 = *D.16568;
  D.16701 = arch_matches ("mips", D.16569);
  if (D.16701 == 0) goto <D.16702>; else goto <D.16659>;
  <D.16702>:
  info->ignore = 1;
  goto <D.16660>;
  <D.16659>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      __s2 = *D.16528;
      D.16706 = "wordsize";
      D.16707 = MEM[(const unsigned char *)D.16706];
      D.16708 = (int) D.16707;
      D.16709 = *__s2;
      D.16710 = (int) D.16709;
      __result = D.16708 - D.16710;
      {
        if (__s2_len != 0) goto <D.16711>; else goto <D.16712>;
        <D.16711>:
        if (__result == 0) goto <D.16713>; else goto <D.16714>;
        <D.16713>:
        D.16715 = &MEM[(void *)"wordsize" + 1B];
        D.16716 = *D.16715;
        D.16717 = (int) D.16716;
        D.16718 = __s2 + 1;
        D.16719 = *D.16718;
        D.16720 = (int) D.16719;
        __result = D.16717 - D.16720;
        if (__s2_len > 1) goto <D.16721>; else goto <D.16722>;
        <D.16721>:
        if (__result == 0) goto <D.16723>; else goto <D.16724>;
        <D.16723>:
        D.16725 = &MEM[(void *)"wordsize" + 2B];
        D.16726 = *D.16725;
        D.16727 = (int) D.16726;
        D.16728 = __s2 + 2;
        D.16729 = *D.16728;
        D.16730 = (int) D.16729;
        __result = D.16727 - D.16730;
        if (__s2_len > 2) goto <D.16731>; else goto <D.16732>;
        <D.16731>:
        if (__result == 0) goto <D.16733>; else goto <D.16734>;
        <D.16733>:
        D.16735 = &MEM[(void *)"wordsize" + 3B];
        D.16736 = *D.16735;
        D.16737 = (int) D.16736;
        D.16738 = __s2 + 3;
        D.16739 = *D.16738;
        D.16740 = (int) D.16739;
        __result = D.16737 - D.16740;
        <D.16734>:
        <D.16732>:
        <D.16724>:
        <D.16722>:
        <D.16714>:
        <D.16712>:
      }
      D.15907 = __result;
    }
    iftmp.18 = -D.15907;
    goto <D.16741>;
    <D.16705>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16528 = attribute_names + D.16527;
    D.16565 = *D.16528;
    iftmp.18 = __builtin_strcmp (D.16565, "wordsize");
    <D.16741>:
    D.15908 = iftmp.18;
  }
  if (D.15908 == 0) goto <D.16742>; else goto <D.16743>;
  <D.16742>:
  i.14 = (unsigned int) i;
  D.16527 = i.14 * 4;
  D.16568 = attribute_values + D.16527;
  D.16569 = *D.16568;
  D.16744 = arch_matches ("32", D.16569);
  if (D.16744 == 0) goto <D.16745>; else goto <D.16746>;
  <D.16745>:
  info->ignore = 1;
  <D.16746>:
  <D.16743>:
  <D.16660>:
  <D.16616>:
  <D.16614>:
  <D.16571>:
  i = i + 1;
  <D.15910>:
  i.14 = (unsigned int) i;
  D.16527 = i.14 * 4;
  D.16528 = attribute_names + D.16527;
  D.16565 = *D.16528;
  if (D.16565 != 0B) goto <D.15909>; else goto <D.15911>;
  <D.15911>:
  D.16747 = info->ignore;
  if (D.16747 == 0) goto <D.16748>; else goto <D.16749>;
  <D.16748>:
  D.16750 = info->assembly;
  D.16521 = info->dll;
  D.16522 = info->target;
  mono_dllmap_insert (D.16750, D.16521, 0B, D.16522, 0B);
  <D.16749>:
  goto <D.16751>;
  <D.16520>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.16755 = "dllentry";
      D.16756 = MEM[(const unsigned char *)D.16755];
      D.16757 = (int) D.16756;
      D.16758 = *__s2;
      D.16759 = (int) D.16758;
      __result = D.16757 - D.16759;
      {
        if (__s2_len != 0) goto <D.16760>; else goto <D.16761>;
        <D.16760>:
        if (__result == 0) goto <D.16762>; else goto <D.16763>;
        <D.16762>:
        D.16764 = &MEM[(void *)"dllentry" + 1B];
        D.16765 = *D.16764;
        D.16766 = (int) D.16765;
        D.16767 = __s2 + 1;
        D.16768 = *D.16767;
        D.16769 = (int) D.16768;
        __result = D.16766 - D.16769;
        if (__s2_len > 1) goto <D.16770>; else goto <D.16771>;
        <D.16770>:
        if (__result == 0) goto <D.16772>; else goto <D.16773>;
        <D.16772>:
        D.16774 = &MEM[(void *)"dllentry" + 2B];
        D.16775 = *D.16774;
        D.16776 = (int) D.16775;
        D.16777 = __s2 + 2;
        D.16778 = *D.16777;
        D.16779 = (int) D.16778;
        __result = D.16776 - D.16779;
        if (__s2_len > 2) goto <D.16780>; else goto <D.16781>;
        <D.16780>:
        if (__result == 0) goto <D.16782>; else goto <D.16783>;
        <D.16782>:
        D.16784 = &MEM[(void *)"dllentry" + 3B];
        D.16785 = *D.16784;
        D.16786 = (int) D.16785;
        D.16787 = __s2 + 3;
        D.16788 = *D.16787;
        D.16789 = (int) D.16788;
        __result = D.16786 - D.16789;
        <D.16783>:
        <D.16781>:
        <D.16773>:
        <D.16771>:
        <D.16763>:
        <D.16761>:
      }
      D.15919 = __result;
    }
    iftmp.19 = -D.15919;
    goto <D.16790>;
    <D.16754>:
    iftmp.19 = __builtin_strcmp (element_name, "dllentry");
    <D.16790>:
    D.15920 = iftmp.19;
  }
  if (D.15920 == 0) goto <D.16791>; else goto <D.16792>;
  <D.16791>:
  {
    const char * name;
    const char * target;
    const char * dll;
    int ignore;

    name = 0B;
    target = 0B;
    dll = 0B;
    ignore = 0;
    i = 0;
    goto <D.15980>;
    <D.15979>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        i.14 = (unsigned int) i;
        D.16527 = i.14 * 4;
        D.16528 = attribute_names + D.16527;
        __s2 = *D.16528;
        D.16529 = "dll";
        D.16530 = MEM[(const unsigned char *)D.16529];
        D.16531 = (int) D.16530;
        D.16796 = *__s2;
        D.16797 = (int) D.16796;
        __result = D.16531 - D.16797;
        {
          if (__s2_len != 0) goto <D.16798>; else goto <D.16799>;
          <D.16798>:
          if (__result == 0) goto <D.16800>; else goto <D.16801>;
          <D.16800>:
          D.16538 = &MEM[(void *)"dll" + 1B];
          D.16539 = *D.16538;
          D.16540 = (int) D.16539;
          D.16802 = __s2 + 1;
          D.16803 = *D.16802;
          D.16804 = (int) D.16803;
          __result = D.16540 - D.16804;
          if (__s2_len > 1) goto <D.16805>; else goto <D.16806>;
          <D.16805>:
          if (__result == 0) goto <D.16807>; else goto <D.16808>;
          <D.16807>:
          D.16548 = &MEM[(void *)"dll" + 2B];
          D.16549 = *D.16548;
          D.16550 = (int) D.16549;
          D.16809 = __s2 + 2;
          D.16810 = *D.16809;
          D.16811 = (int) D.16810;
          __result = D.16550 - D.16811;
          if (__s2_len > 2) goto <D.16812>; else goto <D.16813>;
          <D.16812>:
          if (__result == 0) goto <D.16814>; else goto <D.16815>;
          <D.16814>:
          D.16558 = &MEM[(void *)"dll" + 3B];
          D.16559 = *D.16558;
          D.16560 = (int) D.16559;
          D.16816 = __s2 + 3;
          D.16817 = *D.16816;
          D.16818 = (int) D.16817;
          __result = D.16560 - D.16818;
          <D.16815>:
          <D.16813>:
          <D.16808>:
          <D.16806>:
          <D.16801>:
          <D.16799>:
        }
        D.15932 = __result;
      }
      iftmp.20 = -D.15932;
      goto <D.16819>;
      <D.16795>:
      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      D.16565 = *D.16528;
      iftmp.20 = __builtin_strcmp (D.16565, "dll");
      <D.16819>:
      D.15933 = iftmp.20;
    }
    if (D.15933 == 0) goto <D.16820>; else goto <D.16821>;
    <D.16820>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16568 = attribute_values + D.16527;
    dll = *D.16568;
    goto <D.16822>;
    <D.16821>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        i.14 = (unsigned int) i;
        D.16527 = i.14 * 4;
        D.16528 = attribute_names + D.16527;
        __s2 = *D.16528;
        D.16575 = "target";
        D.16576 = MEM[(const unsigned char *)D.16575];
        D.16577 = (int) D.16576;
        D.16826 = *__s2;
        D.16827 = (int) D.16826;
        __result = D.16577 - D.16827;
        {
          if (__s2_len != 0) goto <D.16828>; else goto <D.16829>;
          <D.16828>:
          if (__result == 0) goto <D.16830>; else goto <D.16831>;
          <D.16830>:
          D.16584 = &MEM[(void *)"target" + 1B];
          D.16585 = *D.16584;
          D.16586 = (int) D.16585;
          D.16832 = __s2 + 1;
          D.16833 = *D.16832;
          D.16834 = (int) D.16833;
          __result = D.16586 - D.16834;
          if (__s2_len > 1) goto <D.16835>; else goto <D.16836>;
          <D.16835>:
          if (__result == 0) goto <D.16837>; else goto <D.16838>;
          <D.16837>:
          D.16594 = &MEM[(void *)"target" + 2B];
          D.16595 = *D.16594;
          D.16596 = (int) D.16595;
          D.16839 = __s2 + 2;
          D.16840 = *D.16839;
          D.16841 = (int) D.16840;
          __result = D.16596 - D.16841;
          if (__s2_len > 2) goto <D.16842>; else goto <D.16843>;
          <D.16842>:
          if (__result == 0) goto <D.16844>; else goto <D.16845>;
          <D.16844>:
          D.16604 = &MEM[(void *)"target" + 3B];
          D.16605 = *D.16604;
          D.16606 = (int) D.16605;
          D.16846 = __s2 + 3;
          D.16847 = *D.16846;
          D.16848 = (int) D.16847;
          __result = D.16606 - D.16848;
          <D.16845>:
          <D.16843>:
          <D.16838>:
          <D.16836>:
          <D.16831>:
          <D.16829>:
        }
        D.15941 = __result;
      }
      iftmp.21 = -D.15941;
      goto <D.16849>;
      <D.16825>:
      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      D.16565 = *D.16528;
      iftmp.21 = __builtin_strcmp (D.16565, "target");
      <D.16849>:
      D.15942 = iftmp.21;
    }
    if (D.15942 == 0) goto <D.16850>; else goto <D.16851>;
    <D.16850>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16568 = attribute_values + D.16527;
    target = *D.16568;
    goto <D.16852>;
    <D.16851>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        i.14 = (unsigned int) i;
        D.16527 = i.14 * 4;
        D.16528 = attribute_names + D.16527;
        __s2 = *D.16528;
        D.16856 = "name";
        D.16857 = MEM[(const unsigned char *)D.16856];
        D.16858 = (int) D.16857;
        D.16859 = *__s2;
        D.16860 = (int) D.16859;
        __result = D.16858 - D.16860;
        {
          if (__s2_len != 0) goto <D.16861>; else goto <D.16862>;
          <D.16861>:
          if (__result == 0) goto <D.16863>; else goto <D.16864>;
          <D.16863>:
          D.16865 = &MEM[(void *)"name" + 1B];
          D.16866 = *D.16865;
          D.16867 = (int) D.16866;
          D.16868 = __s2 + 1;
          D.16869 = *D.16868;
          D.16870 = (int) D.16869;
          __result = D.16867 - D.16870;
          if (__s2_len > 1) goto <D.16871>; else goto <D.16872>;
          <D.16871>:
          if (__result == 0) goto <D.16873>; else goto <D.16874>;
          <D.16873>:
          D.16875 = &MEM[(void *)"name" + 2B];
          D.16876 = *D.16875;
          D.16877 = (int) D.16876;
          D.16878 = __s2 + 2;
          D.16879 = *D.16878;
          D.16880 = (int) D.16879;
          __result = D.16877 - D.16880;
          if (__s2_len > 2) goto <D.16881>; else goto <D.16882>;
          <D.16881>:
          if (__result == 0) goto <D.16883>; else goto <D.16884>;
          <D.16883>:
          D.16885 = &MEM[(void *)"name" + 3B];
          D.16886 = *D.16885;
          D.16887 = (int) D.16886;
          D.16888 = __s2 + 3;
          D.16889 = *D.16888;
          D.16890 = (int) D.16889;
          __result = D.16887 - D.16890;
          <D.16884>:
          <D.16882>:
          <D.16874>:
          <D.16872>:
          <D.16864>:
          <D.16862>:
        }
        D.15950 = __result;
      }
      iftmp.22 = -D.15950;
      goto <D.16891>;
      <D.16855>:
      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      D.16565 = *D.16528;
      iftmp.22 = __builtin_strcmp (D.16565, "name");
      <D.16891>:
      D.15951 = iftmp.22;
    }
    if (D.15951 == 0) goto <D.16892>; else goto <D.16893>;
    <D.16892>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16568 = attribute_values + D.16527;
    name = *D.16568;
    goto <D.16894>;
    <D.16893>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        i.14 = (unsigned int) i;
        D.16527 = i.14 * 4;
        D.16528 = attribute_names + D.16527;
        __s2 = *D.16528;
        D.16620 = "os";
        D.16621 = MEM[(const unsigned char *)D.16620];
        D.16622 = (int) D.16621;
        D.16900 = *__s2;
        D.16901 = (int) D.16900;
        __result = D.16622 - D.16901;
        {
          if (__s2_len != 0) goto <D.16902>; else goto <D.16903>;
          <D.16902>:
          if (__result == 0) goto <D.16904>; else goto <D.16905>;
          <D.16904>:
          D.16629 = &MEM[(void *)"os" + 1B];
          D.16630 = *D.16629;
          D.16631 = (int) D.16630;
          D.16906 = __s2 + 1;
          D.16907 = *D.16906;
          D.16908 = (int) D.16907;
          __result = D.16631 - D.16908;
          if (__s2_len > 1) goto <D.16909>; else goto <D.16910>;
          <D.16909>:
          if (__result == 0) goto <D.16911>; else goto <D.16912>;
          <D.16911>:
          D.16639 = &MEM[(void *)"os" + 2B];
          D.16640 = *D.16639;
          D.16641 = (int) D.16640;
          D.16913 = __s2 + 2;
          D.16914 = *D.16913;
          D.16915 = (int) D.16914;
          __result = D.16641 - D.16915;
          if (__s2_len > 2) goto <D.16916>; else goto <D.16917>;
          <D.16916>:
          if (__result == 0) goto <D.16918>; else goto <D.16919>;
          <D.16918>:
          D.16649 = &MEM[(void *)"os" + 3B];
          D.16650 = *D.16649;
          D.16651 = (int) D.16650;
          D.16920 = __s2 + 3;
          D.16921 = *D.16920;
          D.16922 = (int) D.16921;
          __result = D.16651 - D.16922;
          <D.16919>:
          <D.16917>:
          <D.16912>:
          <D.16910>:
          <D.16905>:
          <D.16903>:
        }
        D.15959 = __result;
      }
      iftmp.23 = -D.15959;
      goto <D.16923>;
      <D.16899>:
      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      D.16565 = *D.16528;
      iftmp.23 = __builtin_strcmp (D.16565, "os");
      <D.16923>:
      D.15960 = iftmp.23;
    }
    if (D.15960 == 0) goto <D.16924>; else goto <D.16895>;
    <D.16924>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16568 = attribute_values + D.16527;
    D.16569 = *D.16568;
    D.16925 = arch_matches ("linux", D.16569);
    if (D.16925 == 0) goto <D.16926>; else goto <D.16895>;
    <D.16926>:
    ignore = 1;
    goto <D.16896>;
    <D.16895>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        i.14 = (unsigned int) i;
        D.16527 = i.14 * 4;
        D.16528 = attribute_names + D.16527;
        __s2 = *D.16528;
        D.16664 = "cpu";
        D.16665 = MEM[(const unsigned char *)D.16664];
        D.16666 = (int) D.16665;
        D.16932 = *__s2;
        D.16933 = (int) D.16932;
        __result = D.16666 - D.16933;
        {
          if (__s2_len != 0) goto <D.16934>; else goto <D.16935>;
          <D.16934>:
          if (__result == 0) goto <D.16936>; else goto <D.16937>;
          <D.16936>:
          D.16673 = &MEM[(void *)"cpu" + 1B];
          D.16674 = *D.16673;
          D.16675 = (int) D.16674;
          D.16938 = __s2 + 1;
          D.16939 = *D.16938;
          D.16940 = (int) D.16939;
          __result = D.16675 - D.16940;
          if (__s2_len > 1) goto <D.16941>; else goto <D.16942>;
          <D.16941>:
          if (__result == 0) goto <D.16943>; else goto <D.16944>;
          <D.16943>:
          D.16683 = &MEM[(void *)"cpu" + 2B];
          D.16684 = *D.16683;
          D.16685 = (int) D.16684;
          D.16945 = __s2 + 2;
          D.16946 = *D.16945;
          D.16947 = (int) D.16946;
          __result = D.16685 - D.16947;
          if (__s2_len > 2) goto <D.16948>; else goto <D.16949>;
          <D.16948>:
          if (__result == 0) goto <D.16950>; else goto <D.16951>;
          <D.16950>:
          D.16693 = &MEM[(void *)"cpu" + 3B];
          D.16694 = *D.16693;
          D.16695 = (int) D.16694;
          D.16952 = __s2 + 3;
          D.16953 = *D.16952;
          D.16954 = (int) D.16953;
          __result = D.16695 - D.16954;
          <D.16951>:
          <D.16949>:
          <D.16944>:
          <D.16942>:
          <D.16937>:
          <D.16935>:
        }
        D.15968 = __result;
      }
      iftmp.24 = -D.15968;
      goto <D.16955>;
      <D.16931>:
      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      D.16565 = *D.16528;
      iftmp.24 = __builtin_strcmp (D.16565, "cpu");
      <D.16955>:
      D.15969 = iftmp.24;
    }
    if (D.15969 == 0) goto <D.16956>; else goto <D.16927>;
    <D.16956>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16568 = attribute_values + D.16527;
    D.16569 = *D.16568;
    D.16957 = arch_matches ("mips", D.16569);
    if (D.16957 == 0) goto <D.16958>; else goto <D.16927>;
    <D.16958>:
    ignore = 1;
    goto <D.16928>;
    <D.16927>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        i.14 = (unsigned int) i;
        D.16527 = i.14 * 4;
        D.16528 = attribute_names + D.16527;
        __s2 = *D.16528;
        D.16706 = "wordsize";
        D.16707 = MEM[(const unsigned char *)D.16706];
        D.16708 = (int) D.16707;
        D.16962 = *__s2;
        D.16963 = (int) D.16962;
        __result = D.16708 - D.16963;
        {
          if (__s2_len != 0) goto <D.16964>; else goto <D.16965>;
          <D.16964>:
          if (__result == 0) goto <D.16966>; else goto <D.16967>;
          <D.16966>:
          D.16715 = &MEM[(void *)"wordsize" + 1B];
          D.16716 = *D.16715;
          D.16717 = (int) D.16716;
          D.16968 = __s2 + 1;
          D.16969 = *D.16968;
          D.16970 = (int) D.16969;
          __result = D.16717 - D.16970;
          if (__s2_len > 1) goto <D.16971>; else goto <D.16972>;
          <D.16971>:
          if (__result == 0) goto <D.16973>; else goto <D.16974>;
          <D.16973>:
          D.16725 = &MEM[(void *)"wordsize" + 2B];
          D.16726 = *D.16725;
          D.16727 = (int) D.16726;
          D.16975 = __s2 + 2;
          D.16976 = *D.16975;
          D.16977 = (int) D.16976;
          __result = D.16727 - D.16977;
          if (__s2_len > 2) goto <D.16978>; else goto <D.16979>;
          <D.16978>:
          if (__result == 0) goto <D.16980>; else goto <D.16981>;
          <D.16980>:
          D.16735 = &MEM[(void *)"wordsize" + 3B];
          D.16736 = *D.16735;
          D.16737 = (int) D.16736;
          D.16982 = __s2 + 3;
          D.16983 = *D.16982;
          D.16984 = (int) D.16983;
          __result = D.16737 - D.16984;
          <D.16981>:
          <D.16979>:
          <D.16974>:
          <D.16972>:
          <D.16967>:
          <D.16965>:
        }
        D.15977 = __result;
      }
      iftmp.25 = -D.15977;
      goto <D.16985>;
      <D.16961>:
      i.14 = (unsigned int) i;
      D.16527 = i.14 * 4;
      D.16528 = attribute_names + D.16527;
      D.16565 = *D.16528;
      iftmp.25 = __builtin_strcmp (D.16565, "wordsize");
      <D.16985>:
      D.15978 = iftmp.25;
    }
    if (D.15978 == 0) goto <D.16986>; else goto <D.16987>;
    <D.16986>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16568 = attribute_values + D.16527;
    D.16569 = *D.16568;
    D.16988 = arch_matches ("32", D.16569);
    if (D.16988 == 0) goto <D.16989>; else goto <D.16990>;
    <D.16989>:
    ignore = 1;
    <D.16990>:
    <D.16987>:
    <D.16928>:
    <D.16896>:
    <D.16894>:
    <D.16852>:
    <D.16822>:
    i = i + 1;
    <D.15980>:
    i.14 = (unsigned int) i;
    D.16527 = i.14 * 4;
    D.16528 = attribute_names + D.16527;
    D.16565 = *D.16528;
    if (D.16565 != 0B) goto <D.15979>; else goto <D.15981>;
    <D.15981>:
    if (dll == 0B) goto <D.16991>; else goto <D.16992>;
    <D.16991>:
    dll = info->dll;
    <D.16992>:
    D.16747 = info->ignore;
    if (D.16747 == 0) goto <D.16993>; else goto <D.16994>;
    <D.16993>:
    if (ignore == 0) goto <D.16995>; else goto <D.16996>;
    <D.16995>:
    D.16750 = info->assembly;
    D.16521 = info->dll;
    mono_dllmap_insert (D.16750, D.16521, name, dll, target);
    <D.16996>:
    <D.16994>:
  }
  <D.16792>:
  <D.16751>:
}


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

  if (str != 0B) goto <D.16997>; else goto <D.16998>;
  <D.16997>:
  D.16999 = __strdup (str);
  return D.16999;
  <D.16998>:
  D.16999 = 0B;
  return D.16999;
}


arch_matches (const char * arch, const char * value)
{
  char D.17001;
  int D.17004;
  const char * D.17005;
  int D.17006;
  _Bool D.17007;
  int D.15833;
  char * D.17008;
  char * * splitted;
  char * * p;
  int found;

  found = 0;
  D.17001 = *value;
  if (D.17001 == 33) goto <D.17002>; else goto <D.17003>;
  <D.17002>:
  D.17005 = value + 1;
  D.17006 = arch_matches (arch, D.17005);
  D.17007 = D.17006 == 0;
  D.17004 = (int) D.17007;
  return D.17004;
  <D.17003>:
  splitted = monoeg_g_strsplit (value, ",", 0);
  p = splitted;
  goto <D.15836>;
  <D.15835>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17008 = *p;
    D.15833 = __builtin_strcmp (arch, D.17008);
  }
  if (D.15833 == 0) goto <D.17009>; else goto <D.17010>;
  <D.17009>:
  found = 1;
  goto <D.15834>;
  <D.17010>:
  p = p + 4;
  <D.15836>:
  D.17008 = *p;
  if (D.17008 != 0B) goto <D.15835>; else goto <D.15834>;
  <D.15834>:
  monoeg_g_strfreev (splitted);
  D.17004 = found;
  return D.17004;
}


dllmap_init (struct MonoImage * assembly)
{
  void * D.17012;
  struct DllInfo * info;

  info = monoeg_malloc0 (16);
  info->assembly = assembly;
  D.17012 = info;
  return D.17012;
}


mono_register_config_for_assembly (const char * assembly_name, const char * config_xml)
{
  struct BundledConfig * bundled_configs.26;
  struct BundledConfig * bconfig;

  bconfig = monoeg_malloc0 (12);
  bconfig->aname = assembly_name;
  bconfig->config_xml = config_xml;
  bundled_configs.26 = bundled_configs;
  bconfig->next = bundled_configs.26;
  bundled_configs = bconfig;
}


mono_config_string_for_assembly_file (const char * filename)
{
  const char * D.17015;
  int D.16079;
  const char * D.17020;
  struct BundledConfig * bconfig;

  bconfig = bundled_configs;
  goto <D.16081>;
  <D.16080>:
  D.17015 = bconfig->aname;
  if (D.17015 != 0B) goto <D.17016>; else goto <D.17017>;
  <D.17016>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17015 = bconfig->aname;
    D.16079 = __builtin_strcmp (D.17015, filename);
  }
  if (D.16079 == 0) goto <D.17018>; else goto <D.17019>;
  <D.17018>:
  D.17020 = bconfig->config_xml;
  return D.17020;
  <D.17019>:
  <D.17017>:
  bconfig = bconfig->next;
  <D.16081>:
  if (bconfig != 0B) goto <D.16080>; else goto <D.16082>;
  <D.16082>:
  D.17020 = 0B;
  return D.17020;
}


mono_config_for_assembly (struct MonoImage * assembly)
{
  const char * D.17022;
  unsigned int D.17025;
  const char * D.17026;
  const char * D.17027;
  const char * D.17028;
  int D.17029;
  struct ParseState state;
  int got_it;
  int i;
  char * aname;
  char * cfg;
  char * cfg_name;
  const char * bundled_config;
  const char * home;

  try
    {
      state = {};
      got_it = 0;
      state.assembly = assembly;
      D.17022 = assembly->module_name;
      bundled_config = mono_config_string_for_assembly_file (D.17022);
      if (bundled_config != 0B) goto <D.17023>; else goto <D.17024>;
      <D.17023>:
      state.user_data = "<bundled>";
      D.17025 = strlen (bundled_config);
      mono_config_parse_xml_with_context (&state, bundled_config, D.17025);
      <D.17024>:
      D.17026 = mono_image_get_filename (assembly);
      cfg_name = monoeg_g_strdup_printf ("%s.config", D.17026);
      mono_config_parse_file_with_context (&state, cfg_name);
      monoeg_g_free (cfg_name);
      D.17027 = mono_image_get_name (assembly);
      cfg_name = monoeg_g_strdup_printf ("%s.config", D.17027);
      home = monoeg_g_get_home_dir ();
      i = 0;
      goto <D.16096>;
      <D.16095>:
      D.17028 = mono_get_config_dir ();
      cfg = monoeg_g_build_path ("/", D.17028, "mono", "assemblies", aname, cfg_name, 0B);
      D.17029 = mono_config_parse_file_with_context (&state, cfg);
      got_it = D.17029 + got_it;
      monoeg_g_free (cfg);
      monoeg_g_free (aname);
      if (got_it != 0) goto <D.16094>; else goto <D.17030>;
      <D.17030>:
      i = i + 1;
      <D.16096>:
      aname = get_assembly_filename (assembly, i);
      if (aname != 0B) goto <D.16095>; else goto <D.16094>;
      <D.16094>:
      monoeg_g_free (cfg_name);
    }
  finally
    {
      state = {CLOBBER};
    }
}


mono_config_parse_file_with_context (struct ParseState * state, const char * filename)
{
  int D.17031;
  int D.17034;
  unsigned int len.27;
  gchar * text.28;
  char D.17039;
  gchar * D.17042;
  char D.17043;
  gchar * D.17046;
  char D.17047;
  void * D.17050;
  sizetype offset.29;
  const char * D.17054;
  unsigned int offset.30;
  unsigned int D.17056;
  gchar * text;
  gsize len;
  gint offset;

  try
    {
      mono_trace (64, 16, "Config attempting to parse: \'%s\'.", filename);
      D.17031 = monoeg_g_file_get_contents (filename, &text, &len, 0B);
      if (D.17031 == 0) goto <D.17032>; else goto <D.17033>;
      <D.17032>:
      D.17034 = 0;
      return D.17034;
      <D.17033>:
      offset = 0;
      len.27 = len;
      if (len.27 > 3) goto <D.17036>; else goto <D.17037>;
      <D.17036>:
      text.28 = text;
      D.17039 = *text.28;
      if (D.17039 == -17) goto <D.17040>; else goto <D.17041>;
      <D.17040>:
      text.28 = text;
      D.17042 = text.28 + 1;
      D.17043 = *D.17042;
      if (D.17043 == -69) goto <D.17044>; else goto <D.17045>;
      <D.17044>:
      text.28 = text;
      D.17046 = text.28 + 2;
      D.17047 = *D.17046;
      if (D.17047 == -65) goto <D.17048>; else goto <D.17049>;
      <D.17048>:
      offset = 3;
      <D.17049>:
      <D.17045>:
      <D.17041>:
      <D.17037>:
      D.17050 = state->user_data;
      if (D.17050 == 0B) goto <D.17051>; else goto <D.17052>;
      <D.17051>:
      state->user_data = filename;
      <D.17052>:
      text.28 = text;
      offset.29 = (sizetype) offset;
      D.17054 = text.28 + offset.29;
      len.27 = len;
      offset.30 = (unsigned int) offset;
      D.17056 = len.27 - offset.30;
      mono_config_parse_xml_with_context (state, D.17054, D.17056);
      text.28 = text;
      monoeg_g_free (text.28);
      D.17034 = 1;
      return D.17034;
    }
  finally
    {
      text = {CLOBBER};
      len = {CLOBBER};
    }
}


get_assembly_filename (struct MonoImage * image, int state)
{
  char * D.17059;
  const char * D.17060;

  switch (state) <default: <D.16054>, case 0: <D.16053>>
  <D.16053>:
  D.17060 = mono_image_get_name (image);
  D.17059 = monoeg_strdup (D.17060);
  return D.17059;
  <D.16054>:
  D.17059 = 0B;
  return D.17059;
}


mono_config_parse (const char * filename)
{
  const char * D.17066;
  const char * home;
  char * mono_cfg;
  char * user_cfg;

  if (filename != 0B) goto <D.17062>; else goto <D.17063>;
  <D.17062>:
  mono_config_parse_file (filename);
  return;
  <D.17063>:
  home = monoeg_g_getenv ("MONO_CONFIG");
  if (home != 0B) goto <D.17064>; else goto <D.17065>;
  <D.17064>:
  mono_config_parse_file (home);
  return;
  <D.17065>:
  D.17066 = mono_get_config_dir ();
  mono_cfg = monoeg_g_build_path ("/", D.17066, "mono", "config", 0B);
  mono_config_parse_file (mono_cfg);
  monoeg_g_free (mono_cfg);
  home = monoeg_g_get_home_dir ();
  user_cfg = monoeg_g_strconcat (home, "/", ".mono/config", 0B);
  mono_config_parse_file (user_cfg);
  monoeg_g_free (user_cfg);
}


mono_config_parse_file (const char * filename)
{
  struct ParseState state;

  try
    {
      state = {};
      state.user_data = filename;
      mono_config_parse_file_with_context (&state, filename);
    }
  finally
    {
      state = {CLOBBER};
    }
}


mono_set_config_dir (const char * dir)
{
  const gchar * mono_cfg_dir.31;
  const char * mono_cfg_dir.32;
  gchar * mono_cfg_dir_allocated.33;
  char * mono_cfg_dir_allocated.34;

  mono_cfg_dir.31 = monoeg_g_getenv ("MONO_CFG_DIR");
  mono_cfg_dir = mono_cfg_dir.31;
  mono_cfg_dir.32 = mono_cfg_dir;
  if (mono_cfg_dir.32 == 0B) goto <D.17070>; else goto <D.17071>;
  <D.17070>:
  mono_cfg_dir_allocated.33 = monoeg_strdup (dir);
  mono_cfg_dir_allocated = mono_cfg_dir_allocated.33;
  mono_cfg_dir_allocated.34 = mono_cfg_dir_allocated;
  mono_cfg_dir = mono_cfg_dir_allocated.34;
  <D.17071>:
}


mono_get_config_dir ()
{
  const char * mono_cfg_dir.35;
  const char * D.17077;

  mono_cfg_dir.35 = mono_cfg_dir;
  if (mono_cfg_dir.35 == 0B) goto <D.17075>; else goto <D.17076>;
  <D.17075>:
  mono_set_dirs (0B, 0B);
  <D.17076>:
  D.17077 = mono_cfg_dir;
  return D.17077;
}


mono_register_machine_config (const char * config_xml)
{
  bundled_machine_config = config_xml;
}


mono_get_machine_config ()
{
  const char * D.17079;

  D.17079 = bundled_machine_config;
  return D.17079;
}


mono_config_parse_publisher_policy (const gchar * filename, struct MonoAssemblyBindingInfo * info)
{
  struct ParserUserData user_data;
  struct ParseState state;

  try
    {
      user_data.info = info;
      user_data.info_parsed = 0B;
      user_data.user_data = 0B;
      state.current = &publisher_policy_parser;
      state.user_data = &user_data;
      state.assembly = 0B;
      state.inited = 1;
      mono_config_parse_file_with_context (&state, filename);
    }
  finally
    {
      user_data = {CLOBBER};
      state = {CLOBBER};
    }
}


publisher_policy_start (void * user_data, const gchar * element_name, const gchar * * attribute_names, const gchar * * attribute_values)
{
  int D.16146;
  int iftmp.36;
  int D.16145;
  const char[18] * D.17084;
  unsigned char D.17085;
  int D.17086;
  unsigned char D.17087;
  int D.17088;
  const unsigned char * D.17093;
  unsigned char D.17094;
  int D.17095;
  const unsigned char * D.17096;
  unsigned char D.17097;
  int D.17098;
  const unsigned char * D.17103;
  unsigned char D.17104;
  int D.17105;
  const unsigned char * D.17106;
  unsigned char D.17107;
  int D.17108;
  const unsigned char * D.17113;
  unsigned char D.17114;
  int D.17115;
  const unsigned char * D.17116;
  unsigned char D.17117;
  int D.17118;
  struct AssemblyVersionSet * D.17122;
  struct AssemblyVersionSet * D.17123;
  struct AssemblyVersionSet * D.17124;
  int D.16155;
  int iftmp.37;
  int D.16154;
  const char[17] * D.17128;
  unsigned char D.17129;
  int D.17130;
  unsigned char D.17131;
  int D.17132;
  const unsigned char * D.17137;
  unsigned char D.17138;
  int D.17139;
  const unsigned char * D.17140;
  unsigned char D.17141;
  int D.17142;
  const unsigned char * D.17147;
  unsigned char D.17148;
  int D.17149;
  const unsigned char * D.17150;
  unsigned char D.17151;
  int D.17152;
  const unsigned char * D.17157;
  unsigned char D.17158;
  int D.17159;
  const unsigned char * D.17160;
  unsigned char D.17161;
  int D.17162;
  unsigned int n.38;
  unsigned int D.17167;
  const gchar * * D.17168;
  int D.16165;
  int iftmp.39;
  int D.16164;
  const char[5] * D.17172;
  unsigned char D.17173;
  int D.17174;
  unsigned char D.17175;
  int D.17176;
  const unsigned char * D.17181;
  unsigned char D.17182;
  int D.17183;
  const unsigned char * D.17184;
  unsigned char D.17185;
  int D.17186;
  const unsigned char * D.17191;
  unsigned char D.17192;
  int D.17193;
  const unsigned char * D.17194;
  unsigned char D.17195;
  int D.17196;
  const unsigned char * D.17201;
  unsigned char D.17202;
  int D.17203;
  const unsigned char * D.17204;
  unsigned char D.17205;
  int D.17206;
  const gchar * * D.17210;
  const gchar * D.17211;
  gchar * D.17212;
  int D.16174;
  int iftmp.40;
  int D.16173;
  const char[15] * D.17217;
  unsigned char D.17218;
  int D.17219;
  unsigned char D.17220;
  int D.17221;
  const unsigned char * D.17226;
  unsigned char D.17227;
  int D.17228;
  const unsigned char * D.17229;
  unsigned char D.17230;
  int D.17231;
  const unsigned char * D.17236;
  unsigned char D.17237;
  int D.17238;
  const unsigned char * D.17239;
  unsigned char D.17240;
  int D.17241;
  const unsigned char * D.17246;
  unsigned char D.17247;
  int D.17248;
  const unsigned char * D.17249;
  unsigned char D.17250;
  int D.17251;
  unsigned int D.17255;
  guchar[17] * D.17258;
  int D.16183;
  int iftmp.41;
  int D.16182;
  const char[8] * D.17263;
  unsigned char D.17264;
  int D.17265;
  unsigned char D.17266;
  int D.17267;
  const unsigned char * D.17272;
  unsigned char D.17273;
  int D.17274;
  const unsigned char * D.17275;
  unsigned char D.17276;
  int D.17277;
  const unsigned char * D.17282;
  unsigned char D.17283;
  int D.17284;
  const unsigned char * D.17285;
  unsigned char D.17286;
  int D.17287;
  const unsigned char * D.17292;
  unsigned char D.17293;
  int D.17294;
  const unsigned char * D.17295;
  unsigned char D.17296;
  int D.17297;
  int D.16192;
  int iftmp.42;
  int D.16191;
  const char[8] * D.17304;
  unsigned char D.17305;
  int D.17306;
  unsigned char D.17307;
  int D.17308;
  const unsigned char * D.17313;
  unsigned char D.17314;
  int D.17315;
  const unsigned char * D.17316;
  unsigned char D.17317;
  int D.17318;
  const unsigned char * D.17323;
  unsigned char D.17324;
  int D.17325;
  const unsigned char * D.17326;
  unsigned char D.17327;
  int D.17328;
  const unsigned char * D.17333;
  unsigned char D.17334;
  int D.17335;
  const unsigned char * D.17336;
  unsigned char D.17337;
  int D.17338;
  gchar * D.17342;
  gchar * D.17344;
  const gchar * D.17345;
  int D.16204;
  int iftmp.43;
  int D.16203;
  const char[16] * D.17350;
  unsigned char D.17351;
  int D.17352;
  unsigned char D.17353;
  int D.17354;
  const unsigned char * D.17359;
  unsigned char D.17360;
  int D.17361;
  const unsigned char * D.17362;
  unsigned char D.17363;
  int D.17364;
  const unsigned char * D.17369;
  unsigned char D.17370;
  int D.17371;
  const unsigned char * D.17372;
  unsigned char D.17373;
  int D.17374;
  const unsigned char * D.17379;
  unsigned char D.17380;
  int D.17381;
  const unsigned char * D.17382;
  unsigned char D.17383;
  int D.17384;
  int D.16214;
  int iftmp.44;
  int D.16213;
  const char[11] * D.17391;
  unsigned char D.17392;
  int D.17393;
  unsigned char D.17394;
  int D.17395;
  const unsigned char * D.17400;
  unsigned char D.17401;
  int D.17402;
  const unsigned char * D.17403;
  unsigned char D.17404;
  int D.17405;
  const unsigned char * D.17410;
  unsigned char D.17411;
  int D.17412;
  const unsigned char * D.17413;
  unsigned char D.17414;
  int D.17415;
  const unsigned char * D.17420;
  unsigned char D.17421;
  int D.17422;
  const unsigned char * D.17423;
  unsigned char D.17424;
  int D.17425;
  int D.16230;
  int iftmp.45;
  int D.16229;
  const char[1] * D.17432;
  unsigned char D.17433;
  int D.17434;
  unsigned char D.17435;
  int D.17436;
  const unsigned char * D.17441;
  unsigned char D.17442;
  int D.17443;
  const unsigned char * D.17444;
  unsigned char D.17445;
  int D.17446;
  const unsigned char * D.17451;
  unsigned char D.17452;
  int D.17453;
  const unsigned char * D.17454;
  unsigned char D.17455;
  int D.17456;
  const unsigned char * D.17461;
  unsigned char D.17462;
  int D.17463;
  const unsigned char * D.17464;
  unsigned char D.17465;
  int D.17466;
  unsigned char D.17468;
  gchar * D.17471;
  int iftmp.46;
  gchar * D.17473;
  gchar * * numbers.47;
  gchar * D.17477;
  int iftmp.48;
  gchar * * numbers.49;
  gchar * D.17483;
  int iftmp.50;
  gchar * * numbers.51;
  gchar * D.17489;
  int iftmp.52;
  short unsigned int D.17500;
  short unsigned int D.17501;
  short unsigned int D.17502;
  short unsigned int D.17503;
  gchar * * D.17504;
  gchar * D.17505;
  int iftmp.53;
  gchar * * numbers.54;
  gchar * D.17512;
  int iftmp.55;
  gchar * * numbers.56;
  gchar * D.17518;
  int iftmp.57;
  gchar * * numbers.58;
  gchar * D.17524;
  int iftmp.59;
  int D.16240;
  int iftmp.60;
  int D.16239;
  const char[11] * D.17539;
  unsigned char D.17540;
  int D.17541;
  unsigned char D.17542;
  int D.17543;
  const unsigned char * D.17548;
  unsigned char D.17549;
  int D.17550;
  const unsigned char * D.17551;
  unsigned char D.17552;
  int D.17553;
  const unsigned char * D.17558;
  unsigned char D.17559;
  int D.17560;
  const unsigned char * D.17561;
  unsigned char D.17562;
  int D.17563;
  const unsigned char * D.17568;
  unsigned char D.17569;
  int D.17570;
  const unsigned char * D.17571;
  unsigned char D.17572;
  int D.17573;
  int D.16251;
  int iftmp.61;
  int D.16250;
  unsigned char D.17580;
  int D.17581;
  const unsigned char * D.17586;
  unsigned char D.17587;
  int D.17588;
  const unsigned char * D.17593;
  unsigned char D.17594;
  int D.17595;
  const unsigned char * D.17600;
  unsigned char D.17601;
  int D.17602;
  guint16 iftmp.62;
  gchar * D.17607;
  gchar * * numbers.63;
  gchar * D.17611;
  int D.17612;
  guint16 iftmp.64;
  gchar * * numbers.65;
  gchar * D.17618;
  int D.17619;
  guint16 iftmp.66;
  gchar * * numbers.67;
  gchar * D.17625;
  int D.17626;
  guint16 iftmp.68;
  int D.17631;
  struct ParserUserData * pud;
  struct MonoAssemblyBindingInfo * info;
  int n;

  pud = user_data;
  info = pud->info;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.17084 = "dependentAssembly";
      D.17085 = MEM[(const unsigned char *)D.17084];
      D.17086 = (int) D.17085;
      D.17087 = *__s2;
      D.17088 = (int) D.17087;
      __result = D.17086 - D.17088;
      {
        if (__s2_len != 0) goto <D.17089>; else goto <D.17090>;
        <D.17089>:
        if (__result == 0) goto <D.17091>; else goto <D.17092>;
        <D.17091>:
        D.17093 = &MEM[(void *)"dependentAssembly" + 1B];
        D.17094 = *D.17093;
        D.17095 = (int) D.17094;
        D.17096 = __s2 + 1;
        D.17097 = *D.17096;
        D.17098 = (int) D.17097;
        __result = D.17095 - D.17098;
        if (__s2_len > 1) goto <D.17099>; else goto <D.17100>;
        <D.17099>:
        if (__result == 0) goto <D.17101>; else goto <D.17102>;
        <D.17101>:
        D.17103 = &MEM[(void *)"dependentAssembly" + 2B];
        D.17104 = *D.17103;
        D.17105 = (int) D.17104;
        D.17106 = __s2 + 2;
        D.17107 = *D.17106;
        D.17108 = (int) D.17107;
        __result = D.17105 - D.17108;
        if (__s2_len > 2) goto <D.17109>; else goto <D.17110>;
        <D.17109>:
        if (__result == 0) goto <D.17111>; else goto <D.17112>;
        <D.17111>:
        D.17113 = &MEM[(void *)"dependentAssembly" + 3B];
        D.17114 = *D.17113;
        D.17115 = (int) D.17114;
        D.17116 = __s2 + 3;
        D.17117 = *D.17116;
        D.17118 = (int) D.17117;
        __result = D.17115 - D.17118;
        <D.17112>:
        <D.17110>:
        <D.17102>:
        <D.17100>:
        <D.17092>:
        <D.17090>:
      }
      D.16145 = __result;
    }
    iftmp.36 = -D.16145;
    goto <D.17119>;
    <D.17083>:
    iftmp.36 = __builtin_strcmp (element_name, "dependentAssembly");
    <D.17119>:
    D.16146 = iftmp.36;
  }
  if (D.16146 == 0) goto <D.17120>; else goto <D.17121>;
  <D.17120>:
  info->name = 0B;
  info->culture = 0B;
  info->has_old_version_bottom = 0;
  info->has_old_version_top = 0;
  info->has_new_version = 0;
  info->is_valid = 0;
  D.17122 = &info->old_version_bottom;
  memset (D.17122, 0, 8);
  D.17123 = &info->old_version_top;
  memset (D.17123, 0, 8);
  D.17124 = &info->new_version;
  memset (D.17124, 0, 8);
  <D.17121>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.17128 = "assemblyIdentity";
      D.17129 = MEM[(const unsigned char *)D.17128];
      D.17130 = (int) D.17129;
      D.17131 = *__s2;
      D.17132 = (int) D.17131;
      __result = D.17130 - D.17132;
      {
        if (__s2_len != 0) goto <D.17133>; else goto <D.17134>;
        <D.17133>:
        if (__result == 0) goto <D.17135>; else goto <D.17136>;
        <D.17135>:
        D.17137 = &MEM[(void *)"assemblyIdentity" + 1B];
        D.17138 = *D.17137;
        D.17139 = (int) D.17138;
        D.17140 = __s2 + 1;
        D.17141 = *D.17140;
        D.17142 = (int) D.17141;
        __result = D.17139 - D.17142;
        if (__s2_len > 1) goto <D.17143>; else goto <D.17144>;
        <D.17143>:
        if (__result == 0) goto <D.17145>; else goto <D.17146>;
        <D.17145>:
        D.17147 = &MEM[(void *)"assemblyIdentity" + 2B];
        D.17148 = *D.17147;
        D.17149 = (int) D.17148;
        D.17150 = __s2 + 2;
        D.17151 = *D.17150;
        D.17152 = (int) D.17151;
        __result = D.17149 - D.17152;
        if (__s2_len > 2) goto <D.17153>; else goto <D.17154>;
        <D.17153>:
        if (__result == 0) goto <D.17155>; else goto <D.17156>;
        <D.17155>:
        D.17157 = &MEM[(void *)"assemblyIdentity" + 3B];
        D.17158 = *D.17157;
        D.17159 = (int) D.17158;
        D.17160 = __s2 + 3;
        D.17161 = *D.17160;
        D.17162 = (int) D.17161;
        __result = D.17159 - D.17162;
        <D.17156>:
        <D.17154>:
        <D.17146>:
        <D.17144>:
        <D.17136>:
        <D.17134>:
      }
      D.16154 = __result;
    }
    iftmp.37 = -D.16154;
    goto <D.17163>;
    <D.17127>:
    iftmp.37 = __builtin_strcmp (element_name, "assemblyIdentity");
    <D.17163>:
    D.16155 = iftmp.37;
  }
  if (D.16155 == 0) goto <D.17164>; else goto <D.17165>;
  <D.17164>:
  n = 0;
  goto <D.16194>;
  <D.16193>:
  {
    const gchar * attribute_name;

    n.38 = (unsigned int) n;
    D.17167 = n.38 * 4;
    D.17168 = attribute_names + D.17167;
    attribute_name = *D.17168;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = attribute_name;
        D.17172 = "name";
        D.17173 = MEM[(const unsigned char *)D.17172];
        D.17174 = (int) D.17173;
        D.17175 = *__s2;
        D.17176 = (int) D.17175;
        __result = D.17174 - D.17176;
        {
          if (__s2_len != 0) goto <D.17177>; else goto <D.17178>;
          <D.17177>:
          if (__result == 0) goto <D.17179>; else goto <D.17180>;
          <D.17179>:
          D.17181 = &MEM[(void *)"name" + 1B];
          D.17182 = *D.17181;
          D.17183 = (int) D.17182;
          D.17184 = __s2 + 1;
          D.17185 = *D.17184;
          D.17186 = (int) D.17185;
          __result = D.17183 - D.17186;
          if (__s2_len > 1) goto <D.17187>; else goto <D.17188>;
          <D.17187>:
          if (__result == 0) goto <D.17189>; else goto <D.17190>;
          <D.17189>:
          D.17191 = &MEM[(void *)"name" + 2B];
          D.17192 = *D.17191;
          D.17193 = (int) D.17192;
          D.17194 = __s2 + 2;
          D.17195 = *D.17194;
          D.17196 = (int) D.17195;
          __result = D.17193 - D.17196;
          if (__s2_len > 2) goto <D.17197>; else goto <D.17198>;
          <D.17197>:
          if (__result == 0) goto <D.17199>; else goto <D.17200>;
          <D.17199>:
          D.17201 = &MEM[(void *)"name" + 3B];
          D.17202 = *D.17201;
          D.17203 = (int) D.17202;
          D.17204 = __s2 + 3;
          D.17205 = *D.17204;
          D.17206 = (int) D.17205;
          __result = D.17203 - D.17206;
          <D.17200>:
          <D.17198>:
          <D.17190>:
          <D.17188>:
          <D.17180>:
          <D.17178>:
        }
        D.16164 = __result;
      }
      iftmp.39 = -D.16164;
      goto <D.17207>;
      <D.17171>:
      iftmp.39 = __builtin_strcmp (attribute_name, "name");
      <D.17207>:
      D.16165 = iftmp.39;
    }
    if (D.16165 == 0) goto <D.17208>; else goto <D.17209>;
    <D.17208>:
    n.38 = (unsigned int) n;
    D.17167 = n.38 * 4;
    D.17210 = attribute_values + D.17167;
    D.17211 = *D.17210;
    D.17212 = monoeg_strdup (D.17211);
    info->name = D.17212;
    goto <D.17213>;
    <D.17209>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = attribute_name;
        D.17217 = "publicKeyToken";
        D.17218 = MEM[(const unsigned char *)D.17217];
        D.17219 = (int) D.17218;
        D.17220 = *__s2;
        D.17221 = (int) D.17220;
        __result = D.17219 - D.17221;
        {
          if (__s2_len != 0) goto <D.17222>; else goto <D.17223>;
          <D.17222>:
          if (__result == 0) goto <D.17224>; else goto <D.17225>;
          <D.17224>:
          D.17226 = &MEM[(void *)"publicKeyToken" + 1B];
          D.17227 = *D.17226;
          D.17228 = (int) D.17227;
          D.17229 = __s2 + 1;
          D.17230 = *D.17229;
          D.17231 = (int) D.17230;
          __result = D.17228 - D.17231;
          if (__s2_len > 1) goto <D.17232>; else goto <D.17233>;
          <D.17232>:
          if (__result == 0) goto <D.17234>; else goto <D.17235>;
          <D.17234>:
          D.17236 = &MEM[(void *)"publicKeyToken" + 2B];
          D.17237 = *D.17236;
          D.17238 = (int) D.17237;
          D.17239 = __s2 + 2;
          D.17240 = *D.17239;
          D.17241 = (int) D.17240;
          __result = D.17238 - D.17241;
          if (__s2_len > 2) goto <D.17242>; else goto <D.17243>;
          <D.17242>:
          if (__result == 0) goto <D.17244>; else goto <D.17245>;
          <D.17244>:
          D.17246 = &MEM[(void *)"publicKeyToken" + 3B];
          D.17247 = *D.17246;
          D.17248 = (int) D.17247;
          D.17249 = __s2 + 3;
          D.17250 = *D.17249;
          D.17251 = (int) D.17250;
          __result = D.17248 - D.17251;
          <D.17245>:
          <D.17243>:
          <D.17235>:
          <D.17233>:
          <D.17225>:
          <D.17223>:
        }
        D.16173 = __result;
      }
      iftmp.40 = -D.16173;
      goto <D.17252>;
      <D.17216>:
      iftmp.40 = __builtin_strcmp (attribute_name, "publicKeyToken");
      <D.17252>:
      D.16174 = iftmp.40;
    }
    if (D.16174 == 0) goto <D.17253>; else goto <D.17254>;
    <D.17253>:
    n.38 = (unsigned int) n;
    D.17167 = n.38 * 4;
    D.17210 = attribute_values + D.17167;
    D.17211 = *D.17210;
    D.17255 = strlen (D.17211);
    if (D.17255 == 16) goto <D.17256>; else goto <D.17257>;
    <D.17256>:
    D.17258 = &info->public_key_token;
    n.38 = (unsigned int) n;
    D.17167 = n.38 * 4;
    D.17210 = attribute_values + D.17167;
    D.17211 = *D.17210;
    monoeg_g_strlcpy (D.17258, D.17211, 17);
    <D.17257>:
    goto <D.17259>;
    <D.17254>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = attribute_name;
        D.17263 = "culture";
        D.17264 = MEM[(const unsigned char *)D.17263];
        D.17265 = (int) D.17264;
        D.17266 = *__s2;
        D.17267 = (int) D.17266;
        __result = D.17265 - D.17267;
        {
          if (__s2_len != 0) goto <D.17268>; else goto <D.17269>;
          <D.17268>:
          if (__result == 0) goto <D.17270>; else goto <D.17271>;
          <D.17270>:
          D.17272 = &MEM[(void *)"culture" + 1B];
          D.17273 = *D.17272;
          D.17274 = (int) D.17273;
          D.17275 = __s2 + 1;
          D.17276 = *D.17275;
          D.17277 = (int) D.17276;
          __result = D.17274 - D.17277;
          if (__s2_len > 1) goto <D.17278>; else goto <D.17279>;
          <D.17278>:
          if (__result == 0) goto <D.17280>; else goto <D.17281>;
          <D.17280>:
          D.17282 = &MEM[(void *)"culture" + 2B];
          D.17283 = *D.17282;
          D.17284 = (int) D.17283;
          D.17285 = __s2 + 2;
          D.17286 = *D.17285;
          D.17287 = (int) D.17286;
          __result = D.17284 - D.17287;
          if (__s2_len > 2) goto <D.17288>; else goto <D.17289>;
          <D.17288>:
          if (__result == 0) goto <D.17290>; else goto <D.17291>;
          <D.17290>:
          D.17292 = &MEM[(void *)"culture" + 3B];
          D.17293 = *D.17292;
          D.17294 = (int) D.17293;
          D.17295 = __s2 + 3;
          D.17296 = *D.17295;
          D.17297 = (int) D.17296;
          __result = D.17294 - D.17297;
          <D.17291>:
          <D.17289>:
          <D.17281>:
          <D.17279>:
          <D.17271>:
          <D.17269>:
        }
        D.16182 = __result;
      }
      iftmp.41 = -D.16182;
      goto <D.17298>;
      <D.17262>:
      iftmp.41 = __builtin_strcmp (attribute_name, "culture");
      <D.17298>:
      D.16183 = iftmp.41;
    }
    if (D.16183 == 0) goto <D.17299>; else goto <D.17300>;
    <D.17299>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        n.38 = (unsigned int) n;
        D.17167 = n.38 * 4;
        D.17210 = attribute_values + D.17167;
        __s2 = *D.17210;
        D.17304 = "neutral";
        D.17305 = MEM[(const unsigned char *)D.17304];
        D.17306 = (int) D.17305;
        D.17307 = *__s2;
        D.17308 = (int) D.17307;
        __result = D.17306 - D.17308;
        {
          if (__s2_len != 0) goto <D.17309>; else goto <D.17310>;
          <D.17309>:
          if (__result == 0) goto <D.17311>; else goto <D.17312>;
          <D.17311>:
          D.17313 = &MEM[(void *)"neutral" + 1B];
          D.17314 = *D.17313;
          D.17315 = (int) D.17314;
          D.17316 = __s2 + 1;
          D.17317 = *D.17316;
          D.17318 = (int) D.17317;
          __result = D.17315 - D.17318;
          if (__s2_len > 1) goto <D.17319>; else goto <D.17320>;
          <D.17319>:
          if (__result == 0) goto <D.17321>; else goto <D.17322>;
          <D.17321>:
          D.17323 = &MEM[(void *)"neutral" + 2B];
          D.17324 = *D.17323;
          D.17325 = (int) D.17324;
          D.17326 = __s2 + 2;
          D.17327 = *D.17326;
          D.17328 = (int) D.17327;
          __result = D.17325 - D.17328;
          if (__s2_len > 2) goto <D.17329>; else goto <D.17330>;
          <D.17329>:
          if (__result == 0) goto <D.17331>; else goto <D.17332>;
          <D.17331>:
          D.17333 = &MEM[(void *)"neutral" + 3B];
          D.17334 = *D.17333;
          D.17335 = (int) D.17334;
          D.17336 = __s2 + 3;
          D.17337 = *D.17336;
          D.17338 = (int) D.17337;
          __result = D.17335 - D.17338;
          <D.17332>:
          <D.17330>:
          <D.17322>:
          <D.17320>:
          <D.17312>:
          <D.17310>:
        }
        D.16191 = __result;
      }
      iftmp.42 = -D.16191;
      goto <D.17339>;
      <D.17303>:
      n.38 = (unsigned int) n;
      D.17167 = n.38 * 4;
      D.17210 = attribute_values + D.17167;
      D.17211 = *D.17210;
      iftmp.42 = __builtin_strcmp (D.17211, "neutral");
      <D.17339>:
      D.16192 = iftmp.42;
    }
    if (D.16192 == 0) goto <D.17340>; else goto <D.17341>;
    <D.17340>:
    D.17342 = monoeg_strdup ("");
    info->culture = D.17342;
    goto <D.17343>;
    <D.17341>:
    n.38 = (unsigned int) n;
    D.17167 = n.38 * 4;
    D.17210 = attribute_values + D.17167;
    D.17211 = *D.17210;
    D.17344 = monoeg_strdup (D.17211);
    info->culture = D.17344;
    <D.17343>:
    <D.17300>:
    <D.17259>:
    <D.17213>:
  }
  n = n + 1;
  <D.16194>:
  n.38 = (unsigned int) n;
  D.17167 = n.38 * 4;
  D.17168 = attribute_names + D.17167;
  D.17345 = *D.17168;
  if (D.17345 != 0B) goto <D.16193>; else goto <D.16195>;
  <D.16195>:
  goto <D.17346>;
  <D.17165>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.17350 = "bindingRedirect";
      D.17351 = MEM[(const unsigned char *)D.17350];
      D.17352 = (int) D.17351;
      D.17353 = *__s2;
      D.17354 = (int) D.17353;
      __result = D.17352 - D.17354;
      {
        if (__s2_len != 0) goto <D.17355>; else goto <D.17356>;
        <D.17355>:
        if (__result == 0) goto <D.17357>; else goto <D.17358>;
        <D.17357>:
        D.17359 = &MEM[(void *)"bindingRedirect" + 1B];
        D.17360 = *D.17359;
        D.17361 = (int) D.17360;
        D.17362 = __s2 + 1;
        D.17363 = *D.17362;
        D.17364 = (int) D.17363;
        __result = D.17361 - D.17364;
        if (__s2_len > 1) goto <D.17365>; else goto <D.17366>;
        <D.17365>:
        if (__result == 0) goto <D.17367>; else goto <D.17368>;
        <D.17367>:
        D.17369 = &MEM[(void *)"bindingRedirect" + 2B];
        D.17370 = *D.17369;
        D.17371 = (int) D.17370;
        D.17372 = __s2 + 2;
        D.17373 = *D.17372;
        D.17374 = (int) D.17373;
        __result = D.17371 - D.17374;
        if (__s2_len > 2) goto <D.17375>; else goto <D.17376>;
        <D.17375>:
        if (__result == 0) goto <D.17377>; else goto <D.17378>;
        <D.17377>:
        D.17379 = &MEM[(void *)"bindingRedirect" + 3B];
        D.17380 = *D.17379;
        D.17381 = (int) D.17380;
        D.17382 = __s2 + 3;
        D.17383 = *D.17382;
        D.17384 = (int) D.17383;
        __result = D.17381 - D.17384;
        <D.17378>:
        <D.17376>:
        <D.17368>:
        <D.17366>:
        <D.17358>:
        <D.17356>:
      }
      D.16203 = __result;
    }
    iftmp.43 = -D.16203;
    goto <D.17385>;
    <D.17349>:
    iftmp.43 = __builtin_strcmp (element_name, "bindingRedirect");
    <D.17385>:
    D.16204 = iftmp.43;
  }
  if (D.16204 == 0) goto <D.17386>; else goto <D.17387>;
  <D.17386>:
  n = 0;
  goto <D.16253>;
  <D.16252>:
  {
    const gchar * attribute_name;

    n.38 = (unsigned int) n;
    D.17167 = n.38 * 4;
    D.17168 = attribute_names + D.17167;
    attribute_name = *D.17168;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = attribute_name;
        D.17391 = "oldVersion";
        D.17392 = MEM[(const unsigned char *)D.17391];
        D.17393 = (int) D.17392;
        D.17394 = *__s2;
        D.17395 = (int) D.17394;
        __result = D.17393 - D.17395;
        {
          if (__s2_len != 0) goto <D.17396>; else goto <D.17397>;
          <D.17396>:
          if (__result == 0) goto <D.17398>; else goto <D.17399>;
          <D.17398>:
          D.17400 = &MEM[(void *)"oldVersion" + 1B];
          D.17401 = *D.17400;
          D.17402 = (int) D.17401;
          D.17403 = __s2 + 1;
          D.17404 = *D.17403;
          D.17405 = (int) D.17404;
          __result = D.17402 - D.17405;
          if (__s2_len > 1) goto <D.17406>; else goto <D.17407>;
          <D.17406>:
          if (__result == 0) goto <D.17408>; else goto <D.17409>;
          <D.17408>:
          D.17410 = &MEM[(void *)"oldVersion" + 2B];
          D.17411 = *D.17410;
          D.17412 = (int) D.17411;
          D.17413 = __s2 + 2;
          D.17414 = *D.17413;
          D.17415 = (int) D.17414;
          __result = D.17412 - D.17415;
          if (__s2_len > 2) goto <D.17416>; else goto <D.17417>;
          <D.17416>:
          if (__result == 0) goto <D.17418>; else goto <D.17419>;
          <D.17418>:
          D.17420 = &MEM[(void *)"oldVersion" + 3B];
          D.17421 = *D.17420;
          D.17422 = (int) D.17421;
          D.17423 = __s2 + 3;
          D.17424 = *D.17423;
          D.17425 = (int) D.17424;
          __result = D.17422 - D.17425;
          <D.17419>:
          <D.17417>:
          <D.17409>:
          <D.17407>:
          <D.17399>:
          <D.17397>:
        }
        D.16213 = __result;
      }
      iftmp.44 = -D.16213;
      goto <D.17426>;
      <D.17390>:
      iftmp.44 = __builtin_strcmp (attribute_name, "oldVersion");
      <D.17426>:
      D.16214 = iftmp.44;
    }
    if (D.16214 == 0) goto <D.17427>; else goto <D.17428>;
    <D.17427>:
    {
      gchar * * numbers;
      gchar * * version;
      gchar * * versions;
      gint major;
      gint minor;
      gint build;
      gint revision;

      {
        size_t __s1_len;
        size_t __s2_len;

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

          n.38 = (unsigned int) n;
          D.17167 = n.38 * 4;
          D.17210 = attribute_values + D.17167;
          __s2 = *D.17210;
          D.17432 = "";
          D.17433 = MEM[(const unsigned char *)D.17432];
          D.17434 = (int) D.17433;
          D.17435 = *__s2;
          D.17436 = (int) D.17435;
          __result = D.17434 - D.17436;
          {
            if (__s2_len != 0) goto <D.17437>; else goto <D.17438>;
            <D.17437>:
            if (__result == 0) goto <D.17439>; else goto <D.17440>;
            <D.17439>:
            D.17441 = &MEM[(void *)"" + 1B];
            D.17442 = *D.17441;
            D.17443 = (int) D.17442;
            D.17444 = __s2 + 1;
            D.17445 = *D.17444;
            D.17446 = (int) D.17445;
            __result = D.17443 - D.17446;
            if (__s2_len > 1) goto <D.17447>; else goto <D.17448>;
            <D.17447>:
            if (__result == 0) goto <D.17449>; else goto <D.17450>;
            <D.17449>:
            D.17451 = &MEM[(void *)"" + 2B];
            D.17452 = *D.17451;
            D.17453 = (int) D.17452;
            D.17454 = __s2 + 2;
            D.17455 = *D.17454;
            D.17456 = (int) D.17455;
            __result = D.17453 - D.17456;
            if (__s2_len > 2) goto <D.17457>; else goto <D.17458>;
            <D.17457>:
            if (__result == 0) goto <D.17459>; else goto <D.17460>;
            <D.17459>:
            D.17461 = &MEM[(void *)"" + 3B];
            D.17462 = *D.17461;
            D.17463 = (int) D.17462;
            D.17464 = __s2 + 3;
            D.17465 = *D.17464;
            D.17466 = (int) D.17465;
            __result = D.17463 - D.17466;
            <D.17460>:
            <D.17458>:
            <D.17450>:
            <D.17448>:
            <D.17440>:
            <D.17438>:
          }
          D.16229 = __result;
        }
        iftmp.45 = -D.16229;
        goto <D.17467>;
        <D.17431>:
        n.38 = (unsigned int) n;
        D.17167 = n.38 * 4;
        D.17210 = attribute_values + D.17167;
        D.17211 = *D.17210;
        D.17468 = MEM[(const unsigned char * {ref-all})D.17211];
        iftmp.45 = (int) D.17468;
        <D.17467>:
        D.16230 = iftmp.45;
      }
      if (D.16230 == 0) goto <D.17469>; else goto <D.17470>;
      <D.17469>:
      return;
      <D.17470>:
      n.38 = (unsigned int) n;
      D.17167 = n.38 * 4;
      D.17210 = attribute_values + D.17167;
      D.17211 = *D.17210;
      versions = monoeg_g_strsplit (D.17211, "-", 2);
      D.17471 = *versions;
      version = monoeg_g_strsplit (D.17471, ".", 4);
      numbers = version;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17474>; else goto <D.17475>;
      <D.17474>:
      numbers.47 = numbers;
      numbers = numbers.47 + 4;
      D.17477 = *numbers.47;
      iftmp.46 = atoi (D.17477);
      goto <D.17478>;
      <D.17475>:
      iftmp.46 = -1;
      <D.17478>:
      major = iftmp.46;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17480>; else goto <D.17481>;
      <D.17480>:
      numbers.49 = numbers;
      numbers = numbers.49 + 4;
      D.17483 = *numbers.49;
      iftmp.48 = atoi (D.17483);
      goto <D.17484>;
      <D.17481>:
      iftmp.48 = -1;
      <D.17484>:
      minor = iftmp.48;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17486>; else goto <D.17487>;
      <D.17486>:
      numbers.51 = numbers;
      numbers = numbers.51 + 4;
      D.17489 = *numbers.51;
      iftmp.50 = atoi (D.17489);
      goto <D.17490>;
      <D.17487>:
      iftmp.50 = -1;
      <D.17490>:
      build = iftmp.50;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17492>; else goto <D.17493>;
      <D.17492>:
      D.17473 = *numbers;
      iftmp.52 = atoi (D.17473);
      goto <D.17494>;
      <D.17493>:
      iftmp.52 = -1;
      <D.17494>:
      revision = iftmp.52;
      monoeg_g_strfreev (version);
      if (major < 0) goto <D.17495>; else goto <D.17497>;
      <D.17497>:
      if (minor < 0) goto <D.17495>; else goto <D.17498>;
      <D.17498>:
      if (build < 0) goto <D.17495>; else goto <D.17499>;
      <D.17499>:
      if (revision < 0) goto <D.17495>; else goto <D.17496>;
      <D.17495>:
      monoeg_g_strfreev (versions);
      return;
      <D.17496>:
      D.17500 = (short unsigned int) major;
      info->old_version_bottom.major = D.17500;
      D.17501 = (short unsigned int) minor;
      info->old_version_bottom.minor = D.17501;
      D.17502 = (short unsigned int) build;
      info->old_version_bottom.build = D.17502;
      D.17503 = (short unsigned int) revision;
      info->old_version_bottom.revision = D.17503;
      info->has_old_version_bottom = 1;
      D.17504 = versions + 4;
      D.17505 = *D.17504;
      if (D.17505 == 0B) goto <D.17506>; else goto <D.17507>;
      <D.17506>:
      monoeg_g_strfreev (versions);
      // predicted unlikely by continue predictor.
      goto <D.16231>;
      <D.17507>:
      D.17504 = versions + 4;
      D.17505 = *D.17504;
      version = monoeg_g_strsplit (D.17505, ".", 4);
      numbers = version;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17509>; else goto <D.17510>;
      <D.17509>:
      numbers.54 = numbers;
      numbers = numbers.54 + 4;
      D.17512 = *numbers.54;
      iftmp.53 = atoi (D.17512);
      goto <D.17513>;
      <D.17510>:
      iftmp.53 = -1;
      <D.17513>:
      major = iftmp.53;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17515>; else goto <D.17516>;
      <D.17515>:
      numbers.56 = numbers;
      numbers = numbers.56 + 4;
      D.17518 = *numbers.56;
      iftmp.55 = atoi (D.17518);
      goto <D.17519>;
      <D.17516>:
      iftmp.55 = -1;
      <D.17519>:
      minor = iftmp.55;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17521>; else goto <D.17522>;
      <D.17521>:
      numbers.58 = numbers;
      numbers = numbers.58 + 4;
      D.17524 = *numbers.58;
      iftmp.57 = atoi (D.17524);
      goto <D.17525>;
      <D.17522>:
      iftmp.57 = -1;
      <D.17525>:
      build = iftmp.57;
      D.17473 = *numbers;
      if (D.17473 != 0B) goto <D.17527>; else goto <D.17528>;
      <D.17527>:
      D.17473 = *numbers;
      iftmp.59 = atoi (D.17473);
      goto <D.17529>;
      <D.17528>:
      iftmp.59 = 1;
      <D.17529>:
      revision = iftmp.59;
      monoeg_g_strfreev (version);
      if (major < 0) goto <D.17530>; else goto <D.17532>;
      <D.17532>:
      if (minor < 0) goto <D.17530>; else goto <D.17533>;
      <D.17533>:
      if (build < 0) goto <D.17530>; else goto <D.17534>;
      <D.17534>:
      if (revision < 0) goto <D.17530>; else goto <D.17531>;
      <D.17530>:
      monoeg_g_strfreev (versions);
      return;
      <D.17531>:
      D.17500 = (short unsigned int) major;
      info->old_version_top.major = D.17500;
      D.17501 = (short unsigned int) minor;
      info->old_version_top.minor = D.17501;
      D.17502 = (short unsigned int) build;
      info->old_version_top.build = D.17502;
      D.17503 = (short unsigned int) revision;
      info->old_version_top.revision = D.17503;
      info->has_old_version_top = 1;
      monoeg_g_strfreev (versions);
    }
    goto <D.17535>;
    <D.17428>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = attribute_name;
        D.17539 = "newVersion";
        D.17540 = MEM[(const unsigned char *)D.17539];
        D.17541 = (int) D.17540;
        D.17542 = *__s2;
        D.17543 = (int) D.17542;
        __result = D.17541 - D.17543;
        {
          if (__s2_len != 0) goto <D.17544>; else goto <D.17545>;
          <D.17544>:
          if (__result == 0) goto <D.17546>; else goto <D.17547>;
          <D.17546>:
          D.17548 = &MEM[(void *)"newVersion" + 1B];
          D.17549 = *D.17548;
          D.17550 = (int) D.17549;
          D.17551 = __s2 + 1;
          D.17552 = *D.17551;
          D.17553 = (int) D.17552;
          __result = D.17550 - D.17553;
          if (__s2_len > 1) goto <D.17554>; else goto <D.17555>;
          <D.17554>:
          if (__result == 0) goto <D.17556>; else goto <D.17557>;
          <D.17556>:
          D.17558 = &MEM[(void *)"newVersion" + 2B];
          D.17559 = *D.17558;
          D.17560 = (int) D.17559;
          D.17561 = __s2 + 2;
          D.17562 = *D.17561;
          D.17563 = (int) D.17562;
          __result = D.17560 - D.17563;
          if (__s2_len > 2) goto <D.17564>; else goto <D.17565>;
          <D.17564>:
          if (__result == 0) goto <D.17566>; else goto <D.17567>;
          <D.17566>:
          D.17568 = &MEM[(void *)"newVersion" + 3B];
          D.17569 = *D.17568;
          D.17570 = (int) D.17569;
          D.17571 = __s2 + 3;
          D.17572 = *D.17571;
          D.17573 = (int) D.17572;
          __result = D.17570 - D.17573;
          <D.17567>:
          <D.17565>:
          <D.17557>:
          <D.17555>:
          <D.17547>:
          <D.17545>:
        }
        D.16239 = __result;
      }
      iftmp.60 = -D.16239;
      goto <D.17574>;
      <D.17538>:
      iftmp.60 = __builtin_strcmp (attribute_name, "newVersion");
      <D.17574>:
      D.16240 = iftmp.60;
    }
    if (D.16240 == 0) goto <D.17575>; else goto <D.17576>;
    <D.17575>:
    {
      gchar * * numbers;
      gchar * * version;

      {
        size_t __s1_len;
        size_t __s2_len;

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

          n.38 = (unsigned int) n;
          D.17167 = n.38 * 4;
          D.17210 = attribute_values + D.17167;
          __s2 = *D.17210;
          D.17432 = "";
          D.17433 = MEM[(const unsigned char *)D.17432];
          D.17434 = (int) D.17433;
          D.17580 = *__s2;
          D.17581 = (int) D.17580;
          __result = D.17434 - D.17581;
          {
            if (__s2_len != 0) goto <D.17582>; else goto <D.17583>;
            <D.17582>:
            if (__result == 0) goto <D.17584>; else goto <D.17585>;
            <D.17584>:
            D.17441 = &MEM[(void *)"" + 1B];
            D.17442 = *D.17441;
            D.17443 = (int) D.17442;
            D.17586 = __s2 + 1;
            D.17587 = *D.17586;
            D.17588 = (int) D.17587;
            __result = D.17443 - D.17588;
            if (__s2_len > 1) goto <D.17589>; else goto <D.17590>;
            <D.17589>:
            if (__result == 0) goto <D.17591>; else goto <D.17592>;
            <D.17591>:
            D.17451 = &MEM[(void *)"" + 2B];
            D.17452 = *D.17451;
            D.17453 = (int) D.17452;
            D.17593 = __s2 + 2;
            D.17594 = *D.17593;
            D.17595 = (int) D.17594;
            __result = D.17453 - D.17595;
            if (__s2_len > 2) goto <D.17596>; else goto <D.17597>;
            <D.17596>:
            if (__result == 0) goto <D.17598>; else goto <D.17599>;
            <D.17598>:
            D.17461 = &MEM[(void *)"" + 3B];
            D.17462 = *D.17461;
            D.17463 = (int) D.17462;
            D.17600 = __s2 + 3;
            D.17601 = *D.17600;
            D.17602 = (int) D.17601;
            __result = D.17463 - D.17602;
            <D.17599>:
            <D.17597>:
            <D.17592>:
            <D.17590>:
            <D.17585>:
            <D.17583>:
          }
          D.16250 = __result;
        }
        iftmp.61 = -D.16250;
        goto <D.17603>;
        <D.17579>:
        n.38 = (unsigned int) n;
        D.17167 = n.38 * 4;
        D.17210 = attribute_values + D.17167;
        D.17211 = *D.17210;
        D.17468 = MEM[(const unsigned char * {ref-all})D.17211];
        iftmp.61 = (int) D.17468;
        <D.17603>:
        D.16251 = iftmp.61;
      }
      if (D.16251 == 0) goto <D.17604>; else goto <D.17605>;
      <D.17604>:
      return;
      <D.17605>:
      n.38 = (unsigned int) n;
      D.17167 = n.38 * 4;
      D.17210 = attribute_values + D.17167;
      D.17211 = *D.17210;
      version = monoeg_g_strsplit (D.17211, ".", 4);
      numbers = version;
      D.17607 = *numbers;
      if (D.17607 != 0B) goto <D.17608>; else goto <D.17609>;
      <D.17608>:
      numbers.63 = numbers;
      numbers = numbers.63 + 4;
      D.17611 = *numbers.63;
      D.17612 = atoi (D.17611);
      iftmp.62 = (guint16) D.17612;
      goto <D.17613>;
      <D.17609>:
      iftmp.62 = 65535;
      <D.17613>:
      info->new_version.major = iftmp.62;
      D.17607 = *numbers;
      if (D.17607 != 0B) goto <D.17615>; else goto <D.17616>;
      <D.17615>:
      numbers.65 = numbers;
      numbers = numbers.65 + 4;
      D.17618 = *numbers.65;
      D.17619 = atoi (D.17618);
      iftmp.64 = (guint16) D.17619;
      goto <D.17620>;
      <D.17616>:
      iftmp.64 = 65535;
      <D.17620>:
      info->new_version.minor = iftmp.64;
      D.17607 = *numbers;
      if (D.17607 != 0B) goto <D.17622>; else goto <D.17623>;
      <D.17622>:
      numbers.67 = numbers;
      numbers = numbers.67 + 4;
      D.17625 = *numbers.67;
      D.17626 = atoi (D.17625);
      iftmp.66 = (guint16) D.17626;
      goto <D.17627>;
      <D.17623>:
      iftmp.66 = 65535;
      <D.17627>:
      info->new_version.build = iftmp.66;
      D.17607 = *numbers;
      if (D.17607 != 0B) goto <D.17629>; else goto <D.17630>;
      <D.17629>:
      D.17607 = *numbers;
      D.17631 = atoi (D.17607);
      iftmp.68 = (guint16) D.17631;
      goto <D.17632>;
      <D.17630>:
      iftmp.68 = 65535;
      <D.17632>:
      info->new_version.revision = iftmp.68;
      info->has_new_version = 1;
      monoeg_g_strfreev (version);
    }
    <D.17576>:
    <D.17535>:
  }
  <D.16231>:
  n = n + 1;
  <D.16253>:
  n.38 = (unsigned int) n;
  D.17167 = n.38 * 4;
  D.17168 = attribute_names + D.17167;
  D.17345 = *D.17168;
  if (D.17345 != 0B) goto <D.16252>; else goto <D.16254>;
  <D.16254>:
  <D.17387>:
  <D.17346>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.17636;
  int D.17641;
  void * D.17643;
  unsigned int D.17644;

  D.17636 = __builtin_constant_p (__len);
  if (D.17636 != 0) goto <D.17637>; else goto <D.17638>;
  <D.17637>:
  if (__len == 0) goto <D.17639>; else goto <D.17640>;
  <D.17639>:
  D.17641 = __builtin_constant_p (__ch);
  if (D.17641 == 0) goto <D.17634>; else goto <D.17642>;
  <D.17642>:
  if (__ch != 0) goto <D.17634>; else goto <D.17635>;
  <D.17634>:
  __warn_memset_zero_len ();
  D.17643 = __dest;
  return D.17643;
  <D.17635>:
  <D.17640>:
  <D.17638>:
  D.17644 = __builtin_object_size (__dest, 0);
  D.17643 = __builtin___memset_chk (__dest, __ch, __len, D.17644);
  return D.17643;
}


atoi (const char * __nptr)
{
  int D.17646;

  D.17646 = strtol (__nptr, 0B, 10);
  return D.17646;
}


mono_config_parse_assembly_bindings (const char * filename, int amajor, int aminor, void * user_data, void (*<T1b95>) (struct MonoAssemblyBindingInfo *, void *) infocb)
{
  struct MonoAssemblyBindingInfo info;
  struct ParserUserData pud;
  struct ParseState state;

  try
    {
      info.major = amajor;
      info.minor = aminor;
      pud.info = &info;
      pud.info_parsed = infocb;
      pud.user_data = user_data;
      state.current = &config_assemblybinding_parser;
      state.user_data = &pud;
      state.assembly = 0B;
      state.inited = 1;
      mono_config_parse_file_with_context (&state, filename);
    }
  finally
    {
      info = {CLOBBER};
      pud = {CLOBBER};
      state = {CLOBBER};
    }
}


assembly_binding_end (void * user_data, const char * element_name)
{
  int D.16128;
  int iftmp.69;
  int D.16127;
  const char[18] * D.17651;
  unsigned char D.17652;
  int D.17653;
  unsigned char D.17654;
  int D.17655;
  const unsigned char * D.17660;
  unsigned char D.17661;
  int D.17662;
  const unsigned char * D.17663;
  unsigned char D.17664;
  int D.17665;
  const unsigned char * D.17670;
  unsigned char D.17671;
  int D.17672;
  const unsigned char * D.17673;
  unsigned char D.17674;
  int D.17675;
  const unsigned char * D.17680;
  unsigned char D.17681;
  int D.17682;
  const unsigned char * D.17683;
  unsigned char D.17684;
  int D.17685;
  void (*<T1b95>) (struct MonoAssemblyBindingInfo *, void *) D.17689;
  struct MonoAssemblyBindingInfo * D.17692;
  void * D.17695;
  char * D.17696;
  char * D.17697;
  struct ParserUserData * pud;

  pud = user_data;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.17651 = "dependentAssembly";
      D.17652 = MEM[(const unsigned char *)D.17651];
      D.17653 = (int) D.17652;
      D.17654 = *__s2;
      D.17655 = (int) D.17654;
      __result = D.17653 - D.17655;
      {
        if (__s2_len != 0) goto <D.17656>; else goto <D.17657>;
        <D.17656>:
        if (__result == 0) goto <D.17658>; else goto <D.17659>;
        <D.17658>:
        D.17660 = &MEM[(void *)"dependentAssembly" + 1B];
        D.17661 = *D.17660;
        D.17662 = (int) D.17661;
        D.17663 = __s2 + 1;
        D.17664 = *D.17663;
        D.17665 = (int) D.17664;
        __result = D.17662 - D.17665;
        if (__s2_len > 1) goto <D.17666>; else goto <D.17667>;
        <D.17666>:
        if (__result == 0) goto <D.17668>; else goto <D.17669>;
        <D.17668>:
        D.17670 = &MEM[(void *)"dependentAssembly" + 2B];
        D.17671 = *D.17670;
        D.17672 = (int) D.17671;
        D.17673 = __s2 + 2;
        D.17674 = *D.17673;
        D.17675 = (int) D.17674;
        __result = D.17672 - D.17675;
        if (__s2_len > 2) goto <D.17676>; else goto <D.17677>;
        <D.17676>:
        if (__result == 0) goto <D.17678>; else goto <D.17679>;
        <D.17678>:
        D.17680 = &MEM[(void *)"dependentAssembly" + 3B];
        D.17681 = *D.17680;
        D.17682 = (int) D.17681;
        D.17683 = __s2 + 3;
        D.17684 = *D.17683;
        D.17685 = (int) D.17684;
        __result = D.17682 - D.17685;
        <D.17679>:
        <D.17677>:
        <D.17669>:
        <D.17667>:
        <D.17659>:
        <D.17657>:
      }
      D.16127 = __result;
    }
    iftmp.69 = -D.16127;
    goto <D.17686>;
    <D.17650>:
    iftmp.69 = __builtin_strcmp (element_name, "dependentAssembly");
    <D.17686>:
    D.16128 = iftmp.69;
  }
  if (D.16128 == 0) goto <D.17687>; else goto <D.17688>;
  <D.17687>:
  D.17689 = pud->info_parsed;
  if (D.17689 != 0B) goto <D.17690>; else goto <D.17691>;
  <D.17690>:
  D.17692 = pud->info;
  if (D.17692 != 0B) goto <D.17693>; else goto <D.17694>;
  <D.17693>:
  D.17689 = pud->info_parsed;
  D.17692 = pud->info;
  D.17695 = pud->user_data;
  D.17689 (D.17692, D.17695);
  D.17692 = pud->info;
  D.17696 = D.17692->name;
  monoeg_g_free (D.17696);
  D.17692 = pud->info;
  D.17697 = D.17692->culture;
  monoeg_g_free (D.17697);
  <D.17694>:
  <D.17691>:
  <D.17688>:
}


mono_config_set_server_mode (mono_bool server_mode)
{
  mono_server_mode = server_mode;
}


mono_config_is_server_mode ()
{
  mono_bool D.17698;

  D.17698 = mono_server_mode;
  return D.17698;
}