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.16547>; else goto <D.16548>;
  <D.16547>:
  config_handlers.0 = config_handlers;
  monoeg_g_hash_table_destroy (config_handlers.0);
  <D.16548>:
  mono_cfg_dir_allocated.1 = mono_cfg_dir_allocated;
  monoeg_g_free (mono_cfg_dir_allocated.1);
}


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

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


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.16551;
  long int __ptr.2;
  long int __str.3;
  long int D.16554;
  char * __ptr;
  char * __tmp;

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


mono_config_parse_xml_with_context (struct ParseState * state, const char * text, gsize len)
{
  int inited.4;
  long int len.5;
  int D.16560;
  struct GMarkupParseContext * context;

  inited.4 = inited;
  if (inited.4 == 0) goto <D.16557>; else goto <D.16558>;
  <D.16557>:
  mono_config_init ();
  <D.16558>:
  context = monoeg_g_markup_parse_context_new (&mono_parser, 0, state, 0B);
  len.5 = (long int) len;
  D.16560 = monoeg_g_markup_parse_context_parse (context, text, len.5, 0B);
  if (D.16560 != 0) goto <D.16561>; else goto <D.16562>;
  <D.16561>:
  monoeg_g_markup_parse_context_end_parse (context, 0B);
  <D.16562>:
  monoeg_g_markup_parse_context_free (context);
}


parse_error (struct GMarkupParseContext * context, struct GError * error, void * user_data)
{
  const gchar * iftmp.6;
  void * D.16567;
  const gchar * iftmp.7;
  gchar * D.16573;
  struct ParseState * state;
  const gchar * msg;
  const gchar * filename;

  state = user_data;
  if (state != 0B) goto <D.16566>; else goto <D.16564>;
  <D.16566>:
  D.16567 = state->user_data;
  if (D.16567 != 0B) goto <D.16568>; else goto <D.16564>;
  <D.16568>:
  iftmp.6 = state->user_data;
  goto <D.16565>;
  <D.16564>:
  iftmp.6 = "<unknown>";
  <D.16565>:
  filename = iftmp.6;
  if (error != 0B) goto <D.16572>; else goto <D.16570>;
  <D.16572>:
  D.16573 = error->message;
  if (D.16573 != 0B) goto <D.16574>; else goto <D.16570>;
  <D.16574>:
  iftmp.7 = error->message;
  goto <D.16571>;
  <D.16570>:
  iftmp.7 = "";
  <D.16571>:
  msg = iftmp.7;
  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.16575;
  void (*<T29e6>) (void *, const char *, gsize) D.16578;
  void * D.16581;
  struct ParseState * state;

  state = user_data;
  D.16575 = state->current;
  if (D.16575 != 0B) goto <D.16576>; else goto <D.16577>;
  <D.16576>:
  D.16575 = state->current;
  D.16578 = D.16575->text;
  if (D.16578 != 0B) goto <D.16579>; else goto <D.16580>;
  <D.16579>:
  D.16575 = state->current;
  D.16578 = D.16575->text;
  D.16581 = state->user_data;
  D.16578 (D.16581, text, text_len);
  <D.16580>:
  <D.16577>:
}


end_element (struct GMarkupParseContext * context, const gchar * element_name, void * user_data, struct GError * * error)
{
  struct MonoParseHandler * D.16582;
  void (*<T29ea>) (void *, const char *) D.16585;
  void * D.16588;
  const char * D.16589;
  int D.16590;
  void (*<Tce2>) (void *) D.16593;
  struct ParseState * state;

  state = user_data;
  D.16582 = state->current;
  if (D.16582 != 0B) goto <D.16583>; else goto <D.16584>;
  <D.16583>:
  D.16582 = state->current;
  D.16585 = D.16582->end;
  if (D.16585 != 0B) goto <D.16586>; else goto <D.16587>;
  <D.16586>:
  D.16582 = state->current;
  D.16585 = D.16582->end;
  D.16588 = state->user_data;
  D.16585 (D.16588, element_name);
  <D.16587>:
  D.16582 = state->current;
  D.16589 = D.16582->element_name;
  D.16590 = strcmp (D.16589, element_name);
  if (D.16590 == 0) goto <D.16591>; else goto <D.16592>;
  <D.16591>:
  D.16582 = state->current;
  D.16593 = D.16582->finish;
  if (D.16593 != 0B) goto <D.16594>; else goto <D.16595>;
  <D.16594>:
  D.16582 = state->current;
  D.16593 = D.16582->finish;
  D.16588 = state->user_data;
  D.16593 (D.16588);
  <D.16595>:
  state->current = 0B;
  state->user_data = 0B;
  <D.16592>:
  <D.16584>:
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.8;
  int iftmp.9;
  int D.16604;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.16597>; else goto <D.16598>;
  <D.16597>:
  if (__ret == 1) goto <D.16600>; else goto <D.16601>;
  <D.16600>:
  iftmp.9 = -1;
  goto <D.16602>;
  <D.16601>:
  iftmp.9 = 1;
  <D.16602>:
  iftmp.8 = iftmp.9;
  goto <D.16603>;
  <D.16598>:
  iftmp.8 = 0;
  <D.16603>:
  __ret = iftmp.8;
  D.16604 = __ret;
  return D.16604;
}


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.16606;
  struct GHashTable * config_handlers.10;
  void * D.16610;
  void * (*<T29de>) (struct MonoImage *) D.16613;
  struct MonoImage * D.16616;
  void * D.16617;
  void (*<T29e2>) (void *, const gchar *, const gchar * *, const gchar * *) D.16620;
  void * D.16623;
  struct ParseState * state;

  state = user_data;
  D.16606 = state->current;
  if (D.16606 == 0B) goto <D.16607>; else goto <D.16608>;
  <D.16607>:
  config_handlers.10 = config_handlers;
  D.16610 = monoeg_g_hash_table_lookup (config_handlers.10, element_name);
  state->current = D.16610;
  D.16606 = state->current;
  if (D.16606 != 0B) goto <D.16611>; else goto <D.16612>;
  <D.16611>:
  D.16606 = state->current;
  D.16613 = D.16606->init;
  if (D.16613 != 0B) goto <D.16614>; else goto <D.16615>;
  <D.16614>:
  D.16606 = state->current;
  D.16613 = D.16606->init;
  D.16616 = state->assembly;
  D.16617 = D.16613 (D.16616);
  state->user_data = D.16617;
  <D.16615>:
  <D.16612>:
  <D.16608>:
  D.16606 = state->current;
  if (D.16606 != 0B) goto <D.16618>; else goto <D.16619>;
  <D.16618>:
  D.16606 = state->current;
  D.16620 = D.16606->start;
  if (D.16620 != 0B) goto <D.16621>; else goto <D.16622>;
  <D.16621>:
  D.16606 = state->current;
  D.16620 = D.16606->start;
  D.16623 = state->user_data;
  D.16620 (D.16623, element_name, attribute_names, attribute_values);
  <D.16622>:
  <D.16619>:
}


mono_config_init ()
{
  struct GHashTable * D.16624;
  struct GHashTable * config_handlers.11;
  const char * D.16626;
  const char * D.16627;

  inited = 1;
  D.16624 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  config_handlers = D.16624;
  config_handlers.11 = config_handlers;
  D.16626 = "dllmap";
  monoeg_g_hash_table_insert_replace (config_handlers.11, D.16626, &dllmap_handler, 0);
  config_handlers.11 = config_handlers;
  D.16627 = "legacyUnhandledExceptionPolicy";
  monoeg_g_hash_table_insert_replace (config_handlers.11, D.16627, &legacyUEP_handler, 0);
}


legacyUEP_start (void * user_data, const gchar * element_name, const gchar * * attribute_names, const gchar * * attribute_values)
{
  int D.16628;
  const gchar * D.16631;
  int D.16634;
  const gchar * D.16639;
  int D.16640;
  int D.16642;

  D.16628 = strcmp (element_name, "legacyUnhandledExceptionPolicy");
  if (D.16628 == 0) goto <D.16629>; else goto <D.16630>;
  <D.16629>:
  D.16631 = *attribute_names;
  if (D.16631 != 0B) goto <D.16632>; else goto <D.16633>;
  <D.16632>:
  D.16631 = *attribute_names;
  D.16634 = strcmp (D.16631, "enabled");
  if (D.16634 == 0) goto <D.16635>; else goto <D.16636>;
  <D.16635>:
  D.16639 = *attribute_values;
  D.16640 = strcmp (D.16639, "1");
  if (D.16640 == 0) goto <D.16637>; else goto <D.16641>;
  <D.16641>:
  D.16639 = *attribute_values;
  D.16642 = monoeg_ascii_strcasecmp (D.16639, "true");
  if (D.16642 == 0) goto <D.16637>; else goto <D.16638>;
  <D.16637>:
  mono_runtime_unhandled_exception_policy_set (0);
  <D.16638>:
  <D.16636>:
  <D.16633>:
  <D.16630>:
}


dllmap_finish (void * user_data)
{
  char * D.16643;
  char * D.16644;
  struct DllInfo * info;

  info = user_data;
  D.16643 = info->dll;
  monoeg_g_free (D.16643);
  D.16644 = info->target;
  monoeg_g_free (D.16644);
  monoeg_g_free (info);
}


dllmap_start (void * user_data, const gchar * element_name, const gchar * * attribute_names, const gchar * * attribute_values)
{
  int D.16645;
  char * D.16648;
  char * D.16649;
  long unsigned int D.16650;
  long unsigned int D.16651;
  const gchar * * D.16652;
  const gchar * D.16653;
  int D.16654;
  const gchar * * D.16657;
  const gchar * D.16658;
  gchar * D.16659;
  int D.16661;
  gchar * D.16664;
  int D.16668;
  int D.16670;
  int D.16674;
  int D.16676;
  int D.16678;
  int D.16681;
  int D.16684;
  struct MonoImage * D.16687;
  int D.16689;
  int D.16692;
  int D.16696;
  int D.16700;
  int D.16706;
  int D.16708;
  int D.16712;
  int D.16714;
  int D.16716;
  int D.16719;
  int i;
  struct DllInfo * info;

  info = user_data;
  D.16645 = strcmp (element_name, "dllmap");
  if (D.16645 == 0) goto <D.16646>; else goto <D.16647>;
  <D.16646>:
  D.16648 = info->dll;
  monoeg_g_free (D.16648);
  D.16649 = info->target;
  monoeg_g_free (D.16649);
  info->target = 0B;
  D.16649 = info->target;
  info->dll = D.16649;
  info->ignore = 0;
  i = 0;
  goto <D.16380>;
  <D.16379>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16652 = attribute_names + D.16651;
  D.16653 = *D.16652;
  D.16654 = strcmp (D.16653, "dll");
  if (D.16654 == 0) goto <D.16655>; else goto <D.16656>;
  <D.16655>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16657 = attribute_values + D.16651;
  D.16658 = *D.16657;
  D.16659 = monoeg_strdup (D.16658);
  info->dll = D.16659;
  goto <D.16660>;
  <D.16656>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16652 = attribute_names + D.16651;
  D.16653 = *D.16652;
  D.16661 = strcmp (D.16653, "target");
  if (D.16661 == 0) goto <D.16662>; else goto <D.16663>;
  <D.16662>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16657 = attribute_values + D.16651;
  D.16658 = *D.16657;
  D.16664 = monoeg_strdup (D.16658);
  info->target = D.16664;
  goto <D.16665>;
  <D.16663>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16652 = attribute_names + D.16651;
  D.16653 = *D.16652;
  D.16668 = strcmp (D.16653, "os");
  if (D.16668 == 0) goto <D.16669>; else goto <D.16666>;
  <D.16669>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16657 = attribute_values + D.16651;
  D.16658 = *D.16657;
  D.16670 = arch_matches ("linux", D.16658);
  if (D.16670 == 0) goto <D.16671>; else goto <D.16666>;
  <D.16671>:
  info->ignore = 1;
  goto <D.16667>;
  <D.16666>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16652 = attribute_names + D.16651;
  D.16653 = *D.16652;
  D.16674 = strcmp (D.16653, "cpu");
  if (D.16674 == 0) goto <D.16675>; else goto <D.16672>;
  <D.16675>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16657 = attribute_values + D.16651;
  D.16658 = *D.16657;
  D.16676 = arch_matches ("s390x", D.16658);
  if (D.16676 == 0) goto <D.16677>; else goto <D.16672>;
  <D.16677>:
  info->ignore = 1;
  goto <D.16673>;
  <D.16672>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16652 = attribute_names + D.16651;
  D.16653 = *D.16652;
  D.16678 = strcmp (D.16653, "wordsize");
  if (D.16678 == 0) goto <D.16679>; else goto <D.16680>;
  <D.16679>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16657 = attribute_values + D.16651;
  D.16658 = *D.16657;
  D.16681 = arch_matches ("64", D.16658);
  if (D.16681 == 0) goto <D.16682>; else goto <D.16683>;
  <D.16682>:
  info->ignore = 1;
  <D.16683>:
  <D.16680>:
  <D.16673>:
  <D.16667>:
  <D.16665>:
  <D.16660>:
  i = i + 1;
  <D.16380>:
  D.16650 = (long unsigned int) i;
  D.16651 = D.16650 * 8;
  D.16652 = attribute_names + D.16651;
  D.16653 = *D.16652;
  if (D.16653 != 0B) goto <D.16379>; else goto <D.16381>;
  <D.16381>:
  D.16684 = info->ignore;
  if (D.16684 == 0) goto <D.16685>; else goto <D.16686>;
  <D.16685>:
  D.16687 = info->assembly;
  D.16648 = info->dll;
  D.16649 = info->target;
  mono_dllmap_insert (D.16687, D.16648, 0B, D.16649, 0B);
  <D.16686>:
  goto <D.16688>;
  <D.16647>:
  D.16689 = strcmp (element_name, "dllentry");
  if (D.16689 == 0) goto <D.16690>; else goto <D.16691>;
  <D.16690>:
  {
    const char * name;
    const char * target;
    const char * dll;
    int ignore;

    name = 0B;
    target = 0B;
    dll = 0B;
    ignore = 0;
    i = 0;
    goto <D.16387>;
    <D.16386>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16652 = attribute_names + D.16651;
    D.16653 = *D.16652;
    D.16692 = strcmp (D.16653, "dll");
    if (D.16692 == 0) goto <D.16693>; else goto <D.16694>;
    <D.16693>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16657 = attribute_values + D.16651;
    dll = *D.16657;
    goto <D.16695>;
    <D.16694>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16652 = attribute_names + D.16651;
    D.16653 = *D.16652;
    D.16696 = strcmp (D.16653, "target");
    if (D.16696 == 0) goto <D.16697>; else goto <D.16698>;
    <D.16697>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16657 = attribute_values + D.16651;
    target = *D.16657;
    goto <D.16699>;
    <D.16698>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16652 = attribute_names + D.16651;
    D.16653 = *D.16652;
    D.16700 = strcmp (D.16653, "name");
    if (D.16700 == 0) goto <D.16701>; else goto <D.16702>;
    <D.16701>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16657 = attribute_values + D.16651;
    name = *D.16657;
    goto <D.16703>;
    <D.16702>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16652 = attribute_names + D.16651;
    D.16653 = *D.16652;
    D.16706 = strcmp (D.16653, "os");
    if (D.16706 == 0) goto <D.16707>; else goto <D.16704>;
    <D.16707>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16657 = attribute_values + D.16651;
    D.16658 = *D.16657;
    D.16708 = arch_matches ("linux", D.16658);
    if (D.16708 == 0) goto <D.16709>; else goto <D.16704>;
    <D.16709>:
    ignore = 1;
    goto <D.16705>;
    <D.16704>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16652 = attribute_names + D.16651;
    D.16653 = *D.16652;
    D.16712 = strcmp (D.16653, "cpu");
    if (D.16712 == 0) goto <D.16713>; else goto <D.16710>;
    <D.16713>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16657 = attribute_values + D.16651;
    D.16658 = *D.16657;
    D.16714 = arch_matches ("s390x", D.16658);
    if (D.16714 == 0) goto <D.16715>; else goto <D.16710>;
    <D.16715>:
    ignore = 1;
    goto <D.16711>;
    <D.16710>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16652 = attribute_names + D.16651;
    D.16653 = *D.16652;
    D.16716 = strcmp (D.16653, "wordsize");
    if (D.16716 == 0) goto <D.16717>; else goto <D.16718>;
    <D.16717>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16657 = attribute_values + D.16651;
    D.16658 = *D.16657;
    D.16719 = arch_matches ("64", D.16658);
    if (D.16719 == 0) goto <D.16720>; else goto <D.16721>;
    <D.16720>:
    ignore = 1;
    <D.16721>:
    <D.16718>:
    <D.16711>:
    <D.16705>:
    <D.16703>:
    <D.16699>:
    <D.16695>:
    i = i + 1;
    <D.16387>:
    D.16650 = (long unsigned int) i;
    D.16651 = D.16650 * 8;
    D.16652 = attribute_names + D.16651;
    D.16653 = *D.16652;
    if (D.16653 != 0B) goto <D.16386>; else goto <D.16388>;
    <D.16388>:
    if (dll == 0B) goto <D.16722>; else goto <D.16723>;
    <D.16722>:
    dll = info->dll;
    <D.16723>:
    D.16684 = info->ignore;
    if (D.16684 == 0) goto <D.16724>; else goto <D.16725>;
    <D.16724>:
    if (ignore == 0) goto <D.16726>; else goto <D.16727>;
    <D.16726>:
    D.16687 = info->assembly;
    D.16648 = info->dll;
    mono_dllmap_insert (D.16687, D.16648, name, dll, target);
    <D.16727>:
    <D.16725>:
  }
  <D.16691>:
  <D.16688>:
}


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

  if (str != 0B) goto <D.16728>; else goto <D.16729>;
  <D.16728>:
  D.16730 = __strdup (str);
  return D.16730;
  <D.16729>:
  D.16730 = 0B;
  return D.16730;
}


arch_matches (const char * arch, const char * value)
{
  char D.16732;
  int D.16735;
  const char * D.16736;
  int D.16737;
  _Bool D.16738;
  char * D.16739;
  int D.16740;
  char * * splitted;
  char * * p;
  int found;

  found = 0;
  D.16732 = *value;
  if (D.16732 == 33) goto <D.16733>; else goto <D.16734>;
  <D.16733>:
  D.16736 = value + 1;
  D.16737 = arch_matches (arch, D.16736);
  D.16738 = D.16737 == 0;
  D.16735 = (int) D.16738;
  return D.16735;
  <D.16734>:
  splitted = monoeg_g_strsplit (value, ",", 0);
  p = splitted;
  goto <D.16360>;
  <D.16359>:
  D.16739 = *p;
  D.16740 = strcmp (arch, D.16739);
  if (D.16740 == 0) goto <D.16741>; else goto <D.16742>;
  <D.16741>:
  found = 1;
  goto <D.16358>;
  <D.16742>:
  p = p + 8;
  <D.16360>:
  D.16739 = *p;
  if (D.16739 != 0B) goto <D.16359>; else goto <D.16358>;
  <D.16358>:
  monoeg_g_strfreev (splitted);
  D.16735 = found;
  return D.16735;
}


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

  info = monoeg_malloc0 (32);
  info->assembly = assembly;
  D.16744 = info;
  return D.16744;
}


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

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


mono_config_string_for_assembly_file (const char * filename)
{
  const char * D.16747;
  int D.16750;
  const char * D.16753;
  struct BundledConfig * bconfig;

  bconfig = bundled_configs;
  goto <D.16452>;
  <D.16451>:
  D.16747 = bconfig->aname;
  if (D.16747 != 0B) goto <D.16748>; else goto <D.16749>;
  <D.16748>:
  D.16747 = bconfig->aname;
  D.16750 = strcmp (D.16747, filename);
  if (D.16750 == 0) goto <D.16751>; else goto <D.16752>;
  <D.16751>:
  D.16753 = bconfig->config_xml;
  return D.16753;
  <D.16752>:
  <D.16749>:
  bconfig = bconfig->next;
  <D.16452>:
  if (bconfig != 0B) goto <D.16451>; else goto <D.16453>;
  <D.16453>:
  D.16753 = 0B;
  return D.16753;
}


mono_config_for_assembly (struct MonoImage * assembly)
{
  const char * D.16755;
  long unsigned int D.16758;
  const char * D.16759;
  const char * D.16760;
  const char * D.16761;
  int D.16762;
  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.16755 = assembly->module_name;
      bundled_config = mono_config_string_for_assembly_file (D.16755);
      if (bundled_config != 0B) goto <D.16756>; else goto <D.16757>;
      <D.16756>:
      state.user_data = "<bundled>";
      D.16758 = __strlen_g (bundled_config);
      mono_config_parse_xml_with_context (&state, bundled_config, D.16758);
      <D.16757>:
      D.16759 = mono_image_get_filename (assembly);
      cfg_name = monoeg_g_strdup_printf ("%s.config", D.16759);
      mono_config_parse_file_with_context (&state, cfg_name);
      monoeg_g_free (cfg_name);
      D.16760 = mono_image_get_name (assembly);
      cfg_name = monoeg_g_strdup_printf ("%s.config", D.16760);
      home = monoeg_g_get_home_dir ();
      i = 0;
      goto <D.16467>;
      <D.16466>:
      D.16761 = mono_get_config_dir ();
      cfg = monoeg_g_build_path ("/", D.16761, "mono", "assemblies", aname, cfg_name, 0B);
      D.16762 = mono_config_parse_file_with_context (&state, cfg);
      got_it = D.16762 + got_it;
      monoeg_g_free (cfg);
      monoeg_g_free (aname);
      if (got_it != 0) goto <D.16465>; else goto <D.16763>;
      <D.16763>:
      i = i + 1;
      <D.16467>:
      aname = get_assembly_filename (assembly, i);
      if (aname != 0B) goto <D.16466>; else goto <D.16465>;
      <D.16465>:
      monoeg_g_free (cfg_name);
    }
  finally
    {
      state = {CLOBBER};
    }
}


mono_config_parse_file_with_context (struct ParseState * state, const char * filename)
{
  int D.16764;
  int D.16767;
  long unsigned int len.13;
  gchar * text.14;
  char D.16772;
  gchar * D.16775;
  char D.16776;
  gchar * D.16779;
  char D.16780;
  void * D.16783;
  sizetype D.16786;
  gchar * D.16787;
  long unsigned int D.16788;
  long unsigned int D.16789;
  gchar * text;
  gsize len;
  gint offset;

  try
    {
      mono_trace (64, 16, "Config attempting to parse: \'%s\'.", filename);
      D.16764 = monoeg_g_file_get_contents (filename, &text, &len, 0B);
      if (D.16764 == 0) goto <D.16765>; else goto <D.16766>;
      <D.16765>:
      D.16767 = 0;
      return D.16767;
      <D.16766>:
      offset = 0;
      len.13 = len;
      if (len.13 > 3) goto <D.16769>; else goto <D.16770>;
      <D.16769>:
      text.14 = text;
      D.16772 = *text.14;
      if (D.16772 == 239) goto <D.16773>; else goto <D.16774>;
      <D.16773>:
      text.14 = text;
      D.16775 = text.14 + 1;
      D.16776 = *D.16775;
      if (D.16776 == 187) goto <D.16777>; else goto <D.16778>;
      <D.16777>:
      text.14 = text;
      D.16779 = text.14 + 2;
      D.16780 = *D.16779;
      if (D.16780 == 191) goto <D.16781>; else goto <D.16782>;
      <D.16781>:
      offset = 3;
      <D.16782>:
      <D.16778>:
      <D.16774>:
      <D.16770>:
      D.16783 = state->user_data;
      if (D.16783 == 0B) goto <D.16784>; else goto <D.16785>;
      <D.16784>:
      state->user_data = filename;
      <D.16785>:
      text.14 = text;
      D.16786 = (sizetype) offset;
      D.16787 = text.14 + D.16786;
      len.13 = len;
      D.16788 = (long unsigned int) offset;
      D.16789 = len.13 - D.16788;
      mono_config_parse_xml_with_context (state, D.16787, D.16789);
      text.14 = text;
      monoeg_g_free (text.14);
      D.16767 = 1;
      return D.16767;
    }
  finally
    {
      text = {CLOBBER};
      len = {CLOBBER};
    }
}


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

  switch (state) <default: <D.16434>, case 0: <D.16433>>
  <D.16433>:
  D.16793 = mono_image_get_name (image);
  D.16792 = monoeg_strdup (D.16793);
  return D.16792;
  <D.16434>:
  D.16792 = 0B;
  return D.16792;
}


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

  if (filename != 0B) goto <D.16795>; else goto <D.16796>;
  <D.16795>:
  mono_config_parse_file (filename);
  return;
  <D.16796>:
  home = monoeg_g_getenv ("MONO_CONFIG");
  if (home != 0B) goto <D.16797>; else goto <D.16798>;
  <D.16797>:
  mono_config_parse_file (home);
  return;
  <D.16798>:
  D.16799 = mono_get_config_dir ();
  mono_cfg = monoeg_g_build_path ("/", D.16799, "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 * D.16801;
  const char * mono_cfg_dir.15;
  gchar * D.16805;
  char * mono_cfg_dir_allocated.16;

  D.16801 = monoeg_g_getenv ("MONO_CFG_DIR");
  mono_cfg_dir = D.16801;
  mono_cfg_dir.15 = mono_cfg_dir;
  if (mono_cfg_dir.15 == 0B) goto <D.16803>; else goto <D.16804>;
  <D.16803>:
  D.16805 = monoeg_strdup (dir);
  mono_cfg_dir_allocated = D.16805;
  mono_cfg_dir_allocated.16 = mono_cfg_dir_allocated;
  mono_cfg_dir = mono_cfg_dir_allocated.16;
  <D.16804>:
}


mono_get_config_dir ()
{
  const char * mono_cfg_dir.17;
  const char * D.16810;

  mono_cfg_dir.17 = mono_cfg_dir;
  if (mono_cfg_dir.17 == 0B) goto <D.16808>; else goto <D.16809>;
  <D.16808>:
  mono_set_dirs (0B, 0B);
  <D.16809>:
  D.16810 = mono_cfg_dir;
  return D.16810;
}


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


mono_get_machine_config ()
{
  const char * D.16812;

  D.16812 = bundled_machine_config;
  return D.16812;
}


__attribute__((visibility ("hidden")))
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.16814;
  struct AssemblyVersionSet * D.16817;
  struct AssemblyVersionSet * D.16818;
  struct AssemblyVersionSet * D.16819;
  int D.16820;
  long unsigned int D.16823;
  long unsigned int D.16824;
  const gchar * * D.16825;
  int D.16826;
  const gchar * * D.16829;
  const gchar * D.16830;
  gchar * D.16831;
  int D.16833;
  long unsigned int D.16836;
  guchar[17] * D.16839;
  int D.16841;
  int D.16844;
  gchar * D.16847;
  gchar * D.16849;
  const gchar * D.16850;
  int D.16852;
  int D.16855;
  unsigned char D.16858;
  gchar * D.16861;
  int iftmp.18;
  gchar * D.16863;
  gchar * * numbers.19;
  gchar * D.16867;
  int iftmp.20;
  gchar * * numbers.21;
  gchar * D.16873;
  int iftmp.22;
  gchar * * numbers.23;
  gchar * D.16879;
  int iftmp.24;
  short unsigned int D.16890;
  short unsigned int D.16891;
  short unsigned int D.16892;
  short unsigned int D.16893;
  gchar * * D.16894;
  gchar * D.16895;
  int iftmp.25;
  gchar * * numbers.26;
  gchar * D.16902;
  int iftmp.27;
  gchar * * numbers.28;
  gchar * D.16908;
  int iftmp.29;
  gchar * * numbers.30;
  gchar * D.16914;
  int iftmp.31;
  int D.16926;
  guint16 iftmp.32;
  gchar * D.16932;
  gchar * * numbers.33;
  gchar * D.16936;
  int D.16937;
  guint16 iftmp.34;
  gchar * * numbers.35;
  gchar * D.16943;
  int D.16944;
  guint16 iftmp.36;
  gchar * * numbers.37;
  gchar * D.16950;
  int D.16951;
  guint16 iftmp.38;
  int D.16956;
  struct ParserUserData * pud;
  struct MonoAssemblyBindingInfo * info;
  int n;

  pud = user_data;
  info = pud->info;
  D.16814 = strcmp (element_name, "dependentAssembly");
  if (D.16814 == 0) goto <D.16815>; else goto <D.16816>;
  <D.16815>:
  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.16817 = &info->old_version_bottom;
  memset (D.16817, 0, 8);
  D.16818 = &info->old_version_top;
  memset (D.16818, 0, 8);
  D.16819 = &info->new_version;
  memset (D.16819, 0, 8);
  <D.16816>:
  D.16820 = strcmp (element_name, "assemblyIdentity");
  if (D.16820 == 0) goto <D.16821>; else goto <D.16822>;
  <D.16821>:
  n = 0;
  goto <D.16502>;
  <D.16501>:
  {
    const gchar * attribute_name;

    D.16823 = (long unsigned int) n;
    D.16824 = D.16823 * 8;
    D.16825 = attribute_names + D.16824;
    attribute_name = *D.16825;
    D.16826 = strcmp (attribute_name, "name");
    if (D.16826 == 0) goto <D.16827>; else goto <D.16828>;
    <D.16827>:
    D.16823 = (long unsigned int) n;
    D.16824 = D.16823 * 8;
    D.16829 = attribute_values + D.16824;
    D.16830 = *D.16829;
    D.16831 = monoeg_strdup (D.16830);
    info->name = D.16831;
    goto <D.16832>;
    <D.16828>:
    D.16833 = strcmp (attribute_name, "publicKeyToken");
    if (D.16833 == 0) goto <D.16834>; else goto <D.16835>;
    <D.16834>:
    D.16823 = (long unsigned int) n;
    D.16824 = D.16823 * 8;
    D.16829 = attribute_values + D.16824;
    D.16830 = *D.16829;
    D.16836 = __strlen_g (D.16830);
    if (D.16836 == 16) goto <D.16837>; else goto <D.16838>;
    <D.16837>:
    D.16839 = &info->public_key_token;
    D.16823 = (long unsigned int) n;
    D.16824 = D.16823 * 8;
    D.16829 = attribute_values + D.16824;
    D.16830 = *D.16829;
    monoeg_g_strlcpy (D.16839, D.16830, 17);
    <D.16838>:
    goto <D.16840>;
    <D.16835>:
    D.16841 = strcmp (attribute_name, "culture");
    if (D.16841 == 0) goto <D.16842>; else goto <D.16843>;
    <D.16842>:
    D.16823 = (long unsigned int) n;
    D.16824 = D.16823 * 8;
    D.16829 = attribute_values + D.16824;
    D.16830 = *D.16829;
    D.16844 = strcmp (D.16830, "neutral");
    if (D.16844 == 0) goto <D.16845>; else goto <D.16846>;
    <D.16845>:
    D.16847 = monoeg_strdup ("");
    info->culture = D.16847;
    goto <D.16848>;
    <D.16846>:
    D.16823 = (long unsigned int) n;
    D.16824 = D.16823 * 8;
    D.16829 = attribute_values + D.16824;
    D.16830 = *D.16829;
    D.16849 = monoeg_strdup (D.16830);
    info->culture = D.16849;
    <D.16848>:
    <D.16843>:
    <D.16840>:
    <D.16832>:
  }
  n = n + 1;
  <D.16502>:
  D.16823 = (long unsigned int) n;
  D.16824 = D.16823 * 8;
  D.16825 = attribute_names + D.16824;
  D.16850 = *D.16825;
  if (D.16850 != 0B) goto <D.16501>; else goto <D.16503>;
  <D.16503>:
  goto <D.16851>;
  <D.16822>:
  D.16852 = strcmp (element_name, "bindingRedirect");
  if (D.16852 == 0) goto <D.16853>; else goto <D.16854>;
  <D.16853>:
  n = 0;
  goto <D.16516>;
  <D.16515>:
  {
    const gchar * attribute_name;

    D.16823 = (long unsigned int) n;
    D.16824 = D.16823 * 8;
    D.16825 = attribute_names + D.16824;
    attribute_name = *D.16825;
    D.16855 = strcmp (attribute_name, "oldVersion");
    if (D.16855 == 0) goto <D.16856>; else goto <D.16857>;
    <D.16856>:
    {
      gchar * * numbers;
      gchar * * version;
      gchar * * versions;
      gint major;
      gint minor;
      gint build;
      gint revision;

      D.16823 = (long unsigned int) n;
      D.16824 = D.16823 * 8;
      D.16829 = attribute_values + D.16824;
      D.16830 = *D.16829;
      D.16858 = MEM[(const unsigned char * {ref-all})D.16830];
      if (D.16858 == 0) goto <D.16859>; else goto <D.16860>;
      <D.16859>:
      return;
      <D.16860>:
      D.16823 = (long unsigned int) n;
      D.16824 = D.16823 * 8;
      D.16829 = attribute_values + D.16824;
      D.16830 = *D.16829;
      versions = monoeg_g_strsplit (D.16830, "-", 2);
      D.16861 = *versions;
      version = monoeg_g_strsplit (D.16861, ".", 4);
      numbers = version;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16864>; else goto <D.16865>;
      <D.16864>:
      numbers.19 = numbers;
      numbers = numbers.19 + 8;
      D.16867 = *numbers.19;
      iftmp.18 = atoi (D.16867);
      goto <D.16868>;
      <D.16865>:
      iftmp.18 = -1;
      <D.16868>:
      major = iftmp.18;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16870>; else goto <D.16871>;
      <D.16870>:
      numbers.21 = numbers;
      numbers = numbers.21 + 8;
      D.16873 = *numbers.21;
      iftmp.20 = atoi (D.16873);
      goto <D.16874>;
      <D.16871>:
      iftmp.20 = -1;
      <D.16874>:
      minor = iftmp.20;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16876>; else goto <D.16877>;
      <D.16876>:
      numbers.23 = numbers;
      numbers = numbers.23 + 8;
      D.16879 = *numbers.23;
      iftmp.22 = atoi (D.16879);
      goto <D.16880>;
      <D.16877>:
      iftmp.22 = -1;
      <D.16880>:
      build = iftmp.22;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16882>; else goto <D.16883>;
      <D.16882>:
      D.16863 = *numbers;
      iftmp.24 = atoi (D.16863);
      goto <D.16884>;
      <D.16883>:
      iftmp.24 = -1;
      <D.16884>:
      revision = iftmp.24;
      monoeg_g_strfreev (version);
      if (major < 0) goto <D.16885>; else goto <D.16887>;
      <D.16887>:
      if (minor < 0) goto <D.16885>; else goto <D.16888>;
      <D.16888>:
      if (build < 0) goto <D.16885>; else goto <D.16889>;
      <D.16889>:
      if (revision < 0) goto <D.16885>; else goto <D.16886>;
      <D.16885>:
      monoeg_g_strfreev (versions);
      return;
      <D.16886>:
      D.16890 = (short unsigned int) major;
      info->old_version_bottom.major = D.16890;
      D.16891 = (short unsigned int) minor;
      info->old_version_bottom.minor = D.16891;
      D.16892 = (short unsigned int) build;
      info->old_version_bottom.build = D.16892;
      D.16893 = (short unsigned int) revision;
      info->old_version_bottom.revision = D.16893;
      info->has_old_version_bottom = 1;
      D.16894 = versions + 8;
      D.16895 = *D.16894;
      if (D.16895 == 0B) goto <D.16896>; else goto <D.16897>;
      <D.16896>:
      monoeg_g_strfreev (versions);
      // predicted unlikely by continue predictor.
      goto <D.16512>;
      <D.16897>:
      D.16894 = versions + 8;
      D.16895 = *D.16894;
      version = monoeg_g_strsplit (D.16895, ".", 4);
      numbers = version;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16899>; else goto <D.16900>;
      <D.16899>:
      numbers.26 = numbers;
      numbers = numbers.26 + 8;
      D.16902 = *numbers.26;
      iftmp.25 = atoi (D.16902);
      goto <D.16903>;
      <D.16900>:
      iftmp.25 = -1;
      <D.16903>:
      major = iftmp.25;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16905>; else goto <D.16906>;
      <D.16905>:
      numbers.28 = numbers;
      numbers = numbers.28 + 8;
      D.16908 = *numbers.28;
      iftmp.27 = atoi (D.16908);
      goto <D.16909>;
      <D.16906>:
      iftmp.27 = -1;
      <D.16909>:
      minor = iftmp.27;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16911>; else goto <D.16912>;
      <D.16911>:
      numbers.30 = numbers;
      numbers = numbers.30 + 8;
      D.16914 = *numbers.30;
      iftmp.29 = atoi (D.16914);
      goto <D.16915>;
      <D.16912>:
      iftmp.29 = -1;
      <D.16915>:
      build = iftmp.29;
      D.16863 = *numbers;
      if (D.16863 != 0B) goto <D.16917>; else goto <D.16918>;
      <D.16917>:
      D.16863 = *numbers;
      iftmp.31 = atoi (D.16863);
      goto <D.16919>;
      <D.16918>:
      iftmp.31 = 1;
      <D.16919>:
      revision = iftmp.31;
      monoeg_g_strfreev (version);
      if (major < 0) goto <D.16920>; else goto <D.16922>;
      <D.16922>:
      if (minor < 0) goto <D.16920>; else goto <D.16923>;
      <D.16923>:
      if (build < 0) goto <D.16920>; else goto <D.16924>;
      <D.16924>:
      if (revision < 0) goto <D.16920>; else goto <D.16921>;
      <D.16920>:
      monoeg_g_strfreev (versions);
      return;
      <D.16921>:
      D.16890 = (short unsigned int) major;
      info->old_version_top.major = D.16890;
      D.16891 = (short unsigned int) minor;
      info->old_version_top.minor = D.16891;
      D.16892 = (short unsigned int) build;
      info->old_version_top.build = D.16892;
      D.16893 = (short unsigned int) revision;
      info->old_version_top.revision = D.16893;
      info->has_old_version_top = 1;
      monoeg_g_strfreev (versions);
    }
    goto <D.16925>;
    <D.16857>:
    D.16926 = strcmp (attribute_name, "newVersion");
    if (D.16926 == 0) goto <D.16927>; else goto <D.16928>;
    <D.16927>:
    {
      gchar * * numbers;
      gchar * * version;

      D.16823 = (long unsigned int) n;
      D.16824 = D.16823 * 8;
      D.16829 = attribute_values + D.16824;
      D.16830 = *D.16829;
      D.16858 = MEM[(const unsigned char * {ref-all})D.16830];
      if (D.16858 == 0) goto <D.16929>; else goto <D.16930>;
      <D.16929>:
      return;
      <D.16930>:
      D.16823 = (long unsigned int) n;
      D.16824 = D.16823 * 8;
      D.16829 = attribute_values + D.16824;
      D.16830 = *D.16829;
      version = monoeg_g_strsplit (D.16830, ".", 4);
      numbers = version;
      D.16932 = *numbers;
      if (D.16932 != 0B) goto <D.16933>; else goto <D.16934>;
      <D.16933>:
      numbers.33 = numbers;
      numbers = numbers.33 + 8;
      D.16936 = *numbers.33;
      D.16937 = atoi (D.16936);
      iftmp.32 = (guint16) D.16937;
      goto <D.16938>;
      <D.16934>:
      iftmp.32 = 65535;
      <D.16938>:
      info->new_version.major = iftmp.32;
      D.16932 = *numbers;
      if (D.16932 != 0B) goto <D.16940>; else goto <D.16941>;
      <D.16940>:
      numbers.35 = numbers;
      numbers = numbers.35 + 8;
      D.16943 = *numbers.35;
      D.16944 = atoi (D.16943);
      iftmp.34 = (guint16) D.16944;
      goto <D.16945>;
      <D.16941>:
      iftmp.34 = 65535;
      <D.16945>:
      info->new_version.minor = iftmp.34;
      D.16932 = *numbers;
      if (D.16932 != 0B) goto <D.16947>; else goto <D.16948>;
      <D.16947>:
      numbers.37 = numbers;
      numbers = numbers.37 + 8;
      D.16950 = *numbers.37;
      D.16951 = atoi (D.16950);
      iftmp.36 = (guint16) D.16951;
      goto <D.16952>;
      <D.16948>:
      iftmp.36 = 65535;
      <D.16952>:
      info->new_version.build = iftmp.36;
      D.16932 = *numbers;
      if (D.16932 != 0B) goto <D.16954>; else goto <D.16955>;
      <D.16954>:
      D.16932 = *numbers;
      D.16956 = atoi (D.16932);
      iftmp.38 = (guint16) D.16956;
      goto <D.16957>;
      <D.16955>:
      iftmp.38 = 65535;
      <D.16957>:
      info->new_version.revision = iftmp.38;
      info->has_new_version = 1;
      monoeg_g_strfreev (version);
    }
    <D.16928>:
    <D.16925>:
  }
  <D.16512>:
  n = n + 1;
  <D.16516>:
  D.16823 = (long unsigned int) n;
  D.16824 = D.16823 * 8;
  D.16825 = attribute_names + D.16824;
  D.16850 = *D.16825;
  if (D.16850 != 0B) goto <D.16515>; else goto <D.16517>;
  <D.16517>:
  <D.16854>:
  <D.16851>:
}


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

  D.16960 = __builtin_object_size (__dest, 0);
  D.16959 = __builtin___memset_chk (__dest, __ch, __len, D.16960);
  return D.16959;
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.16962;
  long int D.16963;

  D.16963 = strtol (__nptr, 0B, 10);
  D.16962 = (int) D.16963;
  return D.16962;
}


__attribute__((visibility ("hidden")))
mono_config_parse_assembly_bindings (const char * filename, int amajor, int aminor, void * user_data, void (*<T1d44>) (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.16965;
  void (*<T1d44>) (struct MonoAssemblyBindingInfo *, void *) D.16968;
  struct MonoAssemblyBindingInfo * D.16971;
  void * D.16974;
  char * D.16975;
  char * D.16976;
  struct ParserUserData * pud;

  pud = user_data;
  D.16965 = strcmp (element_name, "dependentAssembly");
  if (D.16965 == 0) goto <D.16966>; else goto <D.16967>;
  <D.16966>:
  D.16968 = pud->info_parsed;
  if (D.16968 != 0B) goto <D.16969>; else goto <D.16970>;
  <D.16969>:
  D.16971 = pud->info;
  if (D.16971 != 0B) goto <D.16972>; else goto <D.16973>;
  <D.16972>:
  D.16968 = pud->info_parsed;
  D.16971 = pud->info;
  D.16974 = pud->user_data;
  D.16968 (D.16971, D.16974);
  D.16971 = pud->info;
  D.16975 = D.16971->name;
  monoeg_g_free (D.16975);
  D.16971 = pud->info;
  D.16976 = D.16971->culture;
  monoeg_g_free (D.16976);
  <D.16973>:
  <D.16970>:
  <D.16967>:
}


mono_config_set_server_mode (mono_bool server_mode)
{
  mono_server_mode = server_mode;
}


mono_config_is_server_mode ()
{
  mono_bool D.16977;

  D.16977 = mono_server_mode;
  return D.16977;
}