mono_dl_open (const char * name, int flags, char * * error_msg)
{
  gchar * D.7461;
  struct MonoDl * D.7462;
  _Bool D.7463;
  int D.7464;
  void * (*<Tdab>) (const char *, int, char * *, void *) D.7469;
  void * D.7470;
  char * D.7473;
  _Bool D.7478;
  _Bool D.7479;
  _Bool D.7480;
  int D.7408;
  int iftmp.0;
  int D.7407;
  const char[4] * D.7490;
  unsigned char D.7491;
  int D.7492;
  unsigned char D.7493;
  int D.7494;
  _Bool D.7495;
  _Bool D.7496;
  _Bool D.7497;
  const unsigned char * D.7500;
  unsigned char D.7501;
  int D.7502;
  const unsigned char * D.7503;
  unsigned char D.7504;
  int D.7505;
  _Bool D.7506;
  _Bool D.7507;
  const unsigned char * D.7510;
  unsigned char D.7511;
  int D.7512;
  const unsigned char * D.7513;
  unsigned char D.7514;
  int D.7515;
  _Bool D.7516;
  _Bool D.7517;
  const unsigned char * D.7520;
  unsigned char D.7521;
  int D.7522;
  const unsigned char * D.7523;
  unsigned char D.7524;
  int D.7525;
  char * D.7535;
  gchar * D.7536;
  struct MonoDl * module;
  void * lib;
  struct MonoDlFallbackHandler * dl_fallback;
  int lflags;

  dl_fallback = 0B;
  lflags = convert_flags (flags);
  if (error_msg != 0B) goto <D.7455>; else goto <D.7456>;
  <D.7455>:
  *error_msg = 0B;
  <D.7456>:
  module = malloc (12);
  if (module == 0B) goto <D.7457>; else goto <D.7458>;
  <D.7457>:
  if (error_msg != 0B) goto <D.7459>; else goto <D.7460>;
  <D.7459>:
  D.7461 = monoeg_strdup ("Out of memory");
  *error_msg = D.7461;
  <D.7460>:
  D.7462 = 0B;
  return D.7462;
  <D.7458>:
  D.7463 = name == 0B;
  D.7464 = (int) D.7463;
  module->main_module = D.7464;
  lib = dlopen (name, lflags);
  if (lib == 0B) goto <D.7465>; else goto <D.7466>;
  <D.7465>:
  {
    struct GSList * node;

    node = fallback_handlers;
    goto <D.7395>;
    <D.7394>:
    {
      struct MonoDlFallbackHandler * handler;

      handler = node->data;
      if (error_msg != 0B) goto <D.7467>; else goto <D.7468>;
      <D.7467>:
      *error_msg = 0B;
      <D.7468>:
      D.7469 = handler->load_func;
      D.7470 = handler->user_data;
      lib = D.7469 (name, lflags, error_msg, D.7470);
      if (error_msg != 0B) goto <D.7471>; else goto <D.7472>;
      <D.7471>:
      D.7473 = *error_msg;
      if (D.7473 != 0B) goto <D.7474>; else goto <D.7475>;
      <D.7474>:
      D.7473 = *error_msg;
      monoeg_g_free (D.7473);
      <D.7475>:
      <D.7472>:
      if (lib != 0B) goto <D.7476>; else goto <D.7477>;
      <D.7476>:
      dl_fallback = handler;
      goto <D.7393>;
      <D.7477>:
    }
    node = node->next;
    <D.7395>:
    if (node != 0B) goto <D.7394>; else goto <D.7393>;
    <D.7393>:
  }
  <D.7466>:
  D.7478 = lib == 0B;
  D.7479 = dl_fallback == 0B;
  D.7480 = D.7478 & D.7479;
  if (D.7480 != 0) goto <D.7481>; else goto <D.7482>;
  <D.7481>:
  {
    char * lname;
    char * llname;
    const char * suff;
    const char * ext;

    if (name == 0B) goto <D.7483>; else goto <D.7484>;
    <D.7483>:
    free (module);
    D.7462 = 0B;
    return D.7462;
    <D.7484>:
    suff = ".la";
    ext = strrchr (name, 46);
    if (ext != 0B) goto <D.7485>; else goto <D.7486>;
    <D.7485>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = ext;
        D.7490 = ".la";
        D.7491 = MEM[(const unsigned char *)D.7490];
        D.7492 = (int) D.7491;
        D.7493 = *__s2;
        D.7494 = (int) D.7493;
        __result = D.7492 - D.7494;
        {
          D.7495 = __s2_len != 0;
          D.7496 = __result == 0;
          D.7497 = D.7495 & D.7496;
          if (D.7497 != 0) goto <D.7498>; else goto <D.7499>;
          <D.7498>:
          D.7500 = &MEM[(void *)".la" + 1B];
          D.7501 = *D.7500;
          D.7502 = (int) D.7501;
          D.7503 = __s2 + 1;
          D.7504 = *D.7503;
          D.7505 = (int) D.7504;
          __result = D.7502 - D.7505;
          D.7506 = __s2_len > 1;
          D.7496 = __result == 0;
          D.7507 = D.7506 & D.7496;
          if (D.7507 != 0) goto <D.7508>; else goto <D.7509>;
          <D.7508>:
          D.7510 = &MEM[(void *)".la" + 2B];
          D.7511 = *D.7510;
          D.7512 = (int) D.7511;
          D.7513 = __s2 + 2;
          D.7514 = *D.7513;
          D.7515 = (int) D.7514;
          __result = D.7512 - D.7515;
          D.7516 = __s2_len > 2;
          D.7496 = __result == 0;
          D.7517 = D.7516 & D.7496;
          if (D.7517 != 0) goto <D.7518>; else goto <D.7519>;
          <D.7518>:
          D.7520 = &MEM[(void *)".la" + 3B];
          D.7521 = *D.7520;
          D.7522 = (int) D.7521;
          D.7523 = __s2 + 3;
          D.7524 = *D.7523;
          D.7525 = (int) D.7524;
          __result = D.7522 - D.7525;
          <D.7519>:
          <D.7509>:
          <D.7499>:
        }
        D.7407 = __result;
      }
      iftmp.0 = -D.7407;
      goto <D.7526>;
      <D.7489>:
      iftmp.0 = __builtin_strcmp (ext, ".la");
      <D.7526>:
      D.7408 = iftmp.0;
    }
    if (D.7408 == 0) goto <D.7527>; else goto <D.7528>;
    <D.7527>:
    suff = "";
    <D.7528>:
    <D.7486>:
    lname = monoeg_g_strconcat (name, suff, 0B);
    llname = get_dl_name_from_libtool (lname);
    monoeg_g_free (lname);
    if (llname != 0B) goto <D.7529>; else goto <D.7530>;
    <D.7529>:
    lib = dlopen (llname, lflags);
    monoeg_g_free (llname);
    <D.7530>:
    if (lib == 0B) goto <D.7531>; else goto <D.7532>;
    <D.7531>:
    if (error_msg != 0B) goto <D.7533>; else goto <D.7534>;
    <D.7533>:
    D.7535 = dlerror ();
    D.7536 = monoeg_strdup (D.7535);
    *error_msg = D.7536;
    <D.7534>:
    free (module);
    D.7462 = 0B;
    return D.7462;
    <D.7532>:
  }
  <D.7482>:
  module->handle = lib;
  module->dl_fallback = dl_fallback;
  D.7462 = module;
  return D.7462;
}


convert_flags (int flags)
{
  int iftmp.1;
  int D.7539;
  int D.7543;
  int D.7547;
  int lflags;

  D.7539 = flags & 2;
  if (D.7539 != 0) goto <D.7540>; else goto <D.7541>;
  <D.7540>:
  iftmp.1 = 0;
  goto <D.7542>;
  <D.7541>:
  iftmp.1 = 256;
  <D.7542>:
  lflags = iftmp.1;
  D.7543 = flags & 1;
  if (D.7543 != 0) goto <D.7544>; else goto <D.7545>;
  <D.7544>:
  lflags = lflags | 1;
  goto <D.7546>;
  <D.7545>:
  lflags = lflags | 2;
  <D.7546>:
  D.7547 = lflags;
  return D.7547;
}


get_dl_name_from_libtool (const char * libtool_file)
{
  char * D.7551;
  char D.7552;
  const short unsigned int * * D.7554;
  const short unsigned int * D.7555;
  unsigned int D.7556;
  unsigned int D.7557;
  const short unsigned int * D.7558;
  short unsigned int D.7559;
  int D.7560;
  int D.7561;
  char D.7562;
  _Bool D.7563;
  _Bool D.7564;
  _Bool D.7565;
  int D.7568;
  char * D.7571;
  int D.7573;
  int D.7577;
  char * D.7580;
  int D.7380;
  int iftmp.2;
  int D.7379;
  const char[3] * D.7587;
  unsigned char D.7588;
  int D.7589;
  unsigned char D.7590;
  int D.7591;
  _Bool D.7592;
  _Bool D.7593;
  _Bool D.7594;
  const unsigned char * D.7597;
  unsigned char D.7598;
  int D.7599;
  const unsigned char * D.7600;
  unsigned char D.7601;
  int D.7602;
  _Bool D.7603;
  _Bool D.7604;
  const unsigned char * D.7607;
  unsigned char D.7608;
  int D.7609;
  const unsigned char * D.7610;
  unsigned char D.7611;
  int D.7612;
  _Bool D.7613;
  _Bool D.7614;
  const unsigned char * D.7617;
  unsigned char D.7618;
  int D.7619;
  const unsigned char * D.7620;
  unsigned char D.7621;
  int D.7622;
  _Bool D.7627;
  _Bool D.7628;
  _Bool D.7629;
  struct FILE * file;
  char buf[512];
  char * line;
  char * dlname;
  char * libdir;
  char * installed;

  try
    {
      dlname = 0B;
      libdir = 0B;
      installed = 0B;
      file = fopen (libtool_file, "r");
      if (file == 0B) goto <D.7549>; else goto <D.7550>;
      <D.7549>:
      D.7551 = 0B;
      return D.7551;
      <D.7550>:
      goto <D.7342>;
      <D.7370>:
      goto <D.7340>;
      <D.7339>:
      line = line + 1;
      <D.7340>:
      D.7552 = *line;
      if (D.7552 != 0) goto <D.7553>; else goto <D.7341>;
      <D.7553>:
      D.7554 = __ctype_b_loc ();
      D.7555 = *D.7554;
      D.7552 = *line;
      D.7556 = (unsigned int) D.7552;
      D.7557 = D.7556 * 2;
      D.7558 = D.7555 + D.7557;
      D.7559 = *D.7558;
      D.7560 = (int) D.7559;
      D.7561 = D.7560 & 8192;
      if (D.7561 != 0) goto <D.7339>; else goto <D.7341>;
      <D.7341>:
      D.7562 = *line;
      D.7563 = D.7562 == 35;
      D.7564 = D.7562 == 0;
      D.7565 = D.7563 | D.7564;
      if (D.7565 != 0) goto <D.7566>; else goto <D.7567>;
      <D.7566>:
      // predicted unlikely by continue predictor.
      goto <D.7342>;
      <D.7567>:
      D.7568 = strncmp ("dlname", line, 6);
      if (D.7568 == 0) goto <D.7569>; else goto <D.7570>;
      <D.7569>:
      monoeg_g_free (dlname);
      D.7571 = line + 6;
      dlname = read_string (D.7571, file);
      goto <D.7572>;
      <D.7570>:
      D.7573 = strncmp ("libdir", line, 6);
      if (D.7573 == 0) goto <D.7574>; else goto <D.7575>;
      <D.7574>:
      monoeg_g_free (libdir);
      D.7571 = line + 6;
      libdir = read_string (D.7571, file);
      goto <D.7576>;
      <D.7575>:
      D.7577 = strncmp ("installed", line, 9);
      if (D.7577 == 0) goto <D.7578>; else goto <D.7579>;
      <D.7578>:
      monoeg_g_free (installed);
      D.7580 = line + 9;
      installed = read_string (D.7580, file);
      <D.7579>:
      <D.7576>:
      <D.7572>:
      <D.7342>:
      line = fgets (&buf, 512, file);
      if (line != 0B) goto <D.7370>; else goto <D.7371>;
      <D.7371>:
      fclose (file);
      line = 0B;
      if (installed != 0B) goto <D.7583>; else goto <D.7581>;
      <D.7583>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = installed;
          D.7587 = "no";
          D.7588 = MEM[(const unsigned char *)D.7587];
          D.7589 = (int) D.7588;
          D.7590 = *__s2;
          D.7591 = (int) D.7590;
          __result = D.7589 - D.7591;
          {
            D.7592 = __s2_len != 0;
            D.7593 = __result == 0;
            D.7594 = D.7592 & D.7593;
            if (D.7594 != 0) goto <D.7595>; else goto <D.7596>;
            <D.7595>:
            D.7597 = &MEM[(void *)"no" + 1B];
            D.7598 = *D.7597;
            D.7599 = (int) D.7598;
            D.7600 = __s2 + 1;
            D.7601 = *D.7600;
            D.7602 = (int) D.7601;
            __result = D.7599 - D.7602;
            D.7603 = __s2_len > 1;
            D.7593 = __result == 0;
            D.7604 = D.7603 & D.7593;
            if (D.7604 != 0) goto <D.7605>; else goto <D.7606>;
            <D.7605>:
            D.7607 = &MEM[(void *)"no" + 2B];
            D.7608 = *D.7607;
            D.7609 = (int) D.7608;
            D.7610 = __s2 + 2;
            D.7611 = *D.7610;
            D.7612 = (int) D.7611;
            __result = D.7609 - D.7612;
            D.7613 = __s2_len > 2;
            D.7593 = __result == 0;
            D.7614 = D.7613 & D.7593;
            if (D.7614 != 0) goto <D.7615>; else goto <D.7616>;
            <D.7615>:
            D.7617 = &MEM[(void *)"no" + 3B];
            D.7618 = *D.7617;
            D.7619 = (int) D.7618;
            D.7620 = __s2 + 3;
            D.7621 = *D.7620;
            D.7622 = (int) D.7621;
            __result = D.7619 - D.7622;
            <D.7616>:
            <D.7606>:
            <D.7596>:
          }
          D.7379 = __result;
        }
        iftmp.2 = -D.7379;
        goto <D.7623>;
        <D.7586>:
        iftmp.2 = __builtin_strcmp (installed, "no");
        <D.7623>:
        D.7380 = iftmp.2;
      }
      if (D.7380 == 0) goto <D.7624>; else goto <D.7581>;
      <D.7624>:
      {
        char * dir;

        dir = monoeg_g_path_get_dirname (libtool_file);
        if (dlname != 0B) goto <D.7625>; else goto <D.7626>;
        <D.7625>:
        line = monoeg_g_strconcat (dir, "/.libs/", dlname, 0B);
        <D.7626>:
        monoeg_g_free (dir);
      }
      goto <D.7582>;
      <D.7581>:
      D.7627 = libdir != 0B;
      D.7628 = dlname != 0B;
      D.7629 = D.7627 & D.7628;
      if (D.7629 != 0) goto <D.7630>; else goto <D.7631>;
      <D.7630>:
      line = monoeg_g_strconcat (libdir, "/", dlname, 0B);
      <D.7631>:
      <D.7582>:
      monoeg_g_free (dlname);
      monoeg_g_free (libdir);
      monoeg_g_free (installed);
      D.7551 = line;
      return D.7551;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


read_string (char * p, struct FILE * file)
{
  char D.7634;
  const short unsigned int * * D.7636;
  const short unsigned int * D.7637;
  unsigned int D.7638;
  unsigned int D.7639;
  const short unsigned int * D.7640;
  short unsigned int D.7641;
  int D.7642;
  int D.7643;
  char * D.7646;
  char D.7650;
  _Bool D.7651;
  _Bool D.7652;
  _Bool D.7653;
  char * iftmp.3;
  int D.7659;
  int D.7660;
  int endp.4;
  int startp.5;
  int D.7667;
  int D.7668;
  unsigned int D.7669;
  int p.6;
  int D.7674;
  int D.7675;
  unsigned int D.7676;
  char * endp;
  char * startp;

  goto <D.7321>;
  <D.7320>:
  p = p + 1;
  <D.7321>:
  D.7634 = *p;
  if (D.7634 != 0) goto <D.7635>; else goto <D.7322>;
  <D.7635>:
  D.7636 = __ctype_b_loc ();
  D.7637 = *D.7636;
  D.7634 = *p;
  D.7638 = (unsigned int) D.7634;
  D.7639 = D.7638 * 2;
  D.7640 = D.7637 + D.7639;
  D.7641 = *D.7640;
  D.7642 = (int) D.7641;
  D.7643 = D.7642 & 8192;
  if (D.7643 != 0) goto <D.7320>; else goto <D.7322>;
  <D.7322>:
  D.7634 = *p;
  if (D.7634 == 0) goto <D.7644>; else goto <D.7645>;
  <D.7644>:
  D.7646 = 0B;
  return D.7646;
  <D.7645>:
  D.7634 = *p;
  if (D.7634 == 61) goto <D.7647>; else goto <D.7648>;
  <D.7647>:
  p = p + 1;
  <D.7648>:
  goto <D.7324>;
  <D.7323>:
  p = p + 1;
  <D.7324>:
  D.7634 = *p;
  if (D.7634 != 0) goto <D.7649>; else goto <D.7325>;
  <D.7649>:
  D.7636 = __ctype_b_loc ();
  D.7637 = *D.7636;
  D.7634 = *p;
  D.7638 = (unsigned int) D.7634;
  D.7639 = D.7638 * 2;
  D.7640 = D.7637 + D.7639;
  D.7641 = *D.7640;
  D.7642 = (int) D.7641;
  D.7643 = D.7642 & 8192;
  if (D.7643 != 0) goto <D.7323>; else goto <D.7325>;
  <D.7325>:
  D.7650 = *p;
  D.7651 = D.7650 == 39;
  D.7652 = D.7650 == 34;
  D.7653 = D.7651 | D.7652;
  if (D.7653 != 0) goto <D.7654>; else goto <D.7655>;
  <D.7654>:
  {
    char t;

    t = *p;
    p = p + 1;
    startp = p;
    D.7659 = (int) t;
    D.7660 = __builtin_constant_p (D.7659);
    if (D.7660 != 0) goto <D.7661>; else goto <D.7657>;
    <D.7661>:
    if (t == 0) goto <D.7662>; else goto <D.7657>;
    <D.7662>:
    D.7659 = (int) t;
    iftmp.3 = __rawmemchr (p, D.7659);
    goto <D.7658>;
    <D.7657>:
    D.7659 = (int) t;
    iftmp.3 = __builtin_strchr (p, D.7659);
    <D.7658>:
    endp = iftmp.3;
    if (endp == 0B) goto <D.7663>; else goto <D.7664>;
    <D.7663>:
    D.7646 = 0B;
    return D.7646;
    <D.7664>:
    *endp = 0;
    endp.4 = (int) endp;
    startp.5 = (int) startp;
    D.7667 = endp.4 - startp.5;
    D.7668 = D.7667 + 1;
    D.7669 = (unsigned int) D.7668;
    D.7646 = monoeg_g_memdup (startp, D.7669);
    return D.7646;
  }
  <D.7655>:
  D.7634 = *p;
  if (D.7634 == 0) goto <D.7670>; else goto <D.7671>;
  <D.7670>:
  D.7646 = 0B;
  return D.7646;
  <D.7671>:
  startp = p;
  goto <D.7328>;
  <D.7327>:
  p = p + 1;
  <D.7328>:
  D.7634 = *p;
  if (D.7634 != 0) goto <D.7672>; else goto <D.7329>;
  <D.7672>:
  D.7636 = __ctype_b_loc ();
  D.7637 = *D.7636;
  D.7634 = *p;
  D.7638 = (unsigned int) D.7634;
  D.7639 = D.7638 * 2;
  D.7640 = D.7637 + D.7639;
  D.7641 = *D.7640;
  D.7642 = (int) D.7641;
  D.7643 = D.7642 & 8192;
  if (D.7643 == 0) goto <D.7327>; else goto <D.7329>;
  <D.7329>:
  *p = 0;
  p.6 = (int) p;
  startp.5 = (int) startp;
  D.7674 = p.6 - startp.5;
  D.7675 = D.7674 + 1;
  D.7676 = (unsigned int) D.7675;
  D.7646 = monoeg_g_memdup (startp, D.7676);
  return D.7646;
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  unsigned int D.7678;
  int D.7683;
  char * D.7685;
  unsigned int D.7686;
  unsigned int __n.7;
  unsigned int D.7688;
  unsigned int D.7691;

  D.7678 = __builtin_object_size (__s, 1);
  if (D.7678 != 4294967295) goto <D.7679>; else goto <D.7680>;
  <D.7679>:
  D.7683 = __builtin_constant_p (__n);
  if (D.7683 == 0) goto <D.7681>; else goto <D.7684>;
  <D.7684>:
  if (__n <= 0) goto <D.7681>; else goto <D.7682>;
  <D.7681>:
  D.7686 = __builtin_object_size (__s, 1);
  D.7685 = __fgets_chk (__s, D.7686, __n, __stream);
  return D.7685;
  <D.7682>:
  __n.7 = (unsigned int) __n;
  D.7688 = __builtin_object_size (__s, 1);
  if (__n.7 > D.7688) goto <D.7689>; else goto <D.7690>;
  <D.7689>:
  D.7691 = __builtin_object_size (__s, 1);
  D.7685 = __fgets_chk_warn (__s, D.7691, __n, __stream);
  return D.7685;
  <D.7690>:
  <D.7680>:
  D.7685 = __fgets_alias (__s, __n, __stream);
  return D.7685;
}


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

  if (str != 0B) goto <D.7693>; else goto <D.7694>;
  <D.7693>:
  D.7695 = __strdup (str);
  return D.7695;
  <D.7694>:
  D.7695 = 0B;
  return D.7695;
}


mono_dl_symbol (struct MonoDl * module, const char * name, void * * symbol)
{
  struct MonoDlFallbackHandler * D.7697;
  void * (*<Tdae>) (void *, const char *, char * *, void *) D.7700;
  void * D.7701;
  void * D.7702;
  char * D.7708;
  char * iftmp.8;
  char * D.7714;
  void * sym;
  char * err;

  try
    {
      err = 0B;
      D.7697 = module->dl_fallback;
      if (D.7697 != 0B) goto <D.7698>; else goto <D.7699>;
      <D.7698>:
      D.7697 = module->dl_fallback;
      D.7700 = D.7697->symbol_func;
      D.7701 = module->handle;
      D.7697 = module->dl_fallback;
      D.7702 = D.7697->user_data;
      sym = D.7700 (D.7701, name, &err, D.7702);
      goto <D.7703>;
      <D.7699>:
      D.7701 = module->handle;
      sym = dlsym (D.7701, name);
      <D.7703>:
      if (sym != 0B) goto <D.7704>; else goto <D.7705>;
      <D.7704>:
      if (symbol != 0B) goto <D.7706>; else goto <D.7707>;
      <D.7706>:
      *symbol = sym;
      <D.7707>:
      D.7708 = 0B;
      return D.7708;
      <D.7705>:
      if (symbol != 0B) goto <D.7709>; else goto <D.7710>;
      <D.7709>:
      *symbol = 0B;
      <D.7710>:
      D.7697 = module->dl_fallback;
      if (D.7697 == 0B) goto <D.7712>; else goto <D.7713>;
      <D.7712>:
      D.7714 = dlerror ();
      iftmp.8 = monoeg_strdup (D.7714);
      goto <D.7715>;
      <D.7713>:
      iftmp.8 = err;
      <D.7715>:
      D.7708 = iftmp.8;
      return D.7708;
    }
  finally
    {
      err = {CLOBBER};
    }
}


mono_dl_close (struct MonoDl * module)
{
  void * (*<Tdb1>) (void *, void *) D.7720;
  void * D.7723;
  void * D.7724;
  struct MonoDlFallbackHandler * dl_fallback;

  dl_fallback = module->dl_fallback;
  if (dl_fallback != 0B) goto <D.7718>; else goto <D.7719>;
  <D.7718>:
  D.7720 = dl_fallback->close_func;
  if (D.7720 != 0B) goto <D.7721>; else goto <D.7722>;
  <D.7721>:
  D.7720 = dl_fallback->close_func;
  D.7723 = module->handle;
  D.7724 = dl_fallback->user_data;
  D.7720 (D.7723, D.7724);
  <D.7722>:
  goto <D.7725>;
  <D.7719>:
  D.7723 = module->handle;
  dlclose (D.7723);
  <D.7725>:
  free (module);
}


mono_dl_build_path (const char * directory, const char * name, void * * iter)
{
  char * D.7728;
  void * D.7729;
  unsigned int D.7735;
  int D.7741;
  unsigned int prlen.9;
  int D.7440;
  int iftmp.10;
  int D.7439;
  const char[4] * D.7748;
  unsigned char D.7749;
  int D.7750;
  unsigned char D.7751;
  int D.7752;
  _Bool D.7753;
  _Bool D.7754;
  _Bool D.7755;
  const unsigned char * D.7758;
  unsigned char D.7759;
  int D.7760;
  const unsigned char * D.7761;
  unsigned char D.7762;
  int D.7763;
  _Bool D.7764;
  _Bool D.7765;
  const unsigned char * D.7768;
  unsigned char D.7769;
  int D.7770;
  const unsigned char * D.7771;
  unsigned char D.7772;
  int D.7773;
  _Bool D.7774;
  _Bool D.7775;
  const unsigned char * D.7778;
  unsigned char D.7779;
  int D.7780;
  const unsigned char * D.7781;
  unsigned char D.7782;
  int D.7783;
  int D.7786;
  char * D.7792;
  unsigned int D.7793;
  sizetype suffixlen.11;
  sizetype D.7795;
  const char * D.7796;
  char D.7800;
  void * idx.12;
  int idx;
  const char * prefix;
  const char * suffix;
  gboolean first_call;
  int prlen;
  int suffixlen;
  char * res;

  if (iter == 0B) goto <D.7726>; else goto <D.7727>;
  <D.7726>:
  D.7728 = 0B;
  return D.7728;
  <D.7727>:
  D.7729 = *iter;
  idx = (int) D.7729;
  if (idx == 0) goto <D.7730>; else goto <D.7731>;
  <D.7730>:
  first_call = 1;
  suffix = "";
  suffixlen = 0;
  goto <D.7732>;
  <D.7731>:
  idx = idx + -1;
  if (idx != 0) goto <D.7733>; else goto <D.7734>;
  <D.7733>:
  D.7728 = 0B;
  return D.7728;
  <D.7734>:
  first_call = 0;
  suffix = &suffixes[idx];
  D.7735 = strlen (suffix);
  suffixlen = (int) D.7735;
  <D.7732>:
  prlen = 3;
  if (prlen != 0) goto <D.7738>; else goto <D.7736>;
  <D.7738>:
  D.7741 = __builtin_constant_p (prlen);
  if (D.7741 != 0) goto <D.7742>; else goto <D.7739>;
  <D.7742>:
  prlen.9 = (unsigned int) prlen;
  if (prlen.9 > 3) goto <D.7744>; else goto <D.7739>;
  <D.7744>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.7748 = "lib";
      D.7749 = MEM[(const unsigned char *)D.7748];
      D.7750 = (int) D.7749;
      D.7751 = *__s2;
      D.7752 = (int) D.7751;
      __result = D.7750 - D.7752;
      {
        D.7753 = __s2_len != 0;
        D.7754 = __result == 0;
        D.7755 = D.7753 & D.7754;
        if (D.7755 != 0) goto <D.7756>; else goto <D.7757>;
        <D.7756>:
        D.7758 = &MEM[(void *)"lib" + 1B];
        D.7759 = *D.7758;
        D.7760 = (int) D.7759;
        D.7761 = __s2 + 1;
        D.7762 = *D.7761;
        D.7763 = (int) D.7762;
        __result = D.7760 - D.7763;
        D.7764 = __s2_len > 1;
        D.7754 = __result == 0;
        D.7765 = D.7764 & D.7754;
        if (D.7765 != 0) goto <D.7766>; else goto <D.7767>;
        <D.7766>:
        D.7768 = &MEM[(void *)"lib" + 2B];
        D.7769 = *D.7768;
        D.7770 = (int) D.7769;
        D.7771 = __s2 + 2;
        D.7772 = *D.7771;
        D.7773 = (int) D.7772;
        __result = D.7770 - D.7773;
        D.7774 = __s2_len > 2;
        D.7754 = __result == 0;
        D.7775 = D.7774 & D.7754;
        if (D.7775 != 0) goto <D.7776>; else goto <D.7777>;
        <D.7776>:
        D.7778 = &MEM[(void *)"lib" + 3B];
        D.7779 = *D.7778;
        D.7780 = (int) D.7779;
        D.7781 = __s2 + 3;
        D.7782 = *D.7781;
        D.7783 = (int) D.7782;
        __result = D.7780 - D.7783;
        <D.7777>:
        <D.7767>:
        <D.7757>:
      }
      D.7439 = __result;
    }
    iftmp.10 = -D.7439;
    goto <D.7784>;
    <D.7747>:
    iftmp.10 = __builtin_strcmp (name, "lib");
    <D.7784>:
    D.7440 = iftmp.10;
  }
  if (D.7440 != 0) goto <D.7785>; else goto <D.7736>;
  <D.7785>:
  goto <D.7740>;
  <D.7739>:
  prlen.9 = (unsigned int) prlen;
  D.7786 = strncmp (name, "lib", prlen.9);
  if (D.7786 != 0) goto <D.7787>; else goto <D.7736>;
  <D.7787>:
  <D.7740>:
  prefix = "lib";
  goto <D.7737>;
  <D.7736>:
  prefix = "";
  <D.7737>:
  if (first_call != 0) goto <D.7788>; else goto <D.7790>;
  <D.7790>:
  if (suffixlen != 0) goto <D.7791>; else goto <D.7789>;
  <D.7791>:
  D.7792 = strstr (name, suffix);
  D.7793 = strlen (name);
  suffixlen.11 = (sizetype) suffixlen;
  D.7795 = D.7793 - suffixlen.11;
  D.7796 = name + D.7795;
  if (D.7792 == D.7796) goto <D.7788>; else goto <D.7789>;
  <D.7788>:
  suffix = "";
  <D.7789>:
  if (directory != 0B) goto <D.7799>; else goto <D.7797>;
  <D.7799>:
  D.7800 = *directory;
  if (D.7800 != 0) goto <D.7801>; else goto <D.7797>;
  <D.7801>:
  res = monoeg_g_strconcat (directory, "/", prefix, name, suffix, 0B);
  goto <D.7798>;
  <D.7797>:
  res = monoeg_g_strconcat (prefix, name, suffix, 0B);
  <D.7798>:
  idx = idx + 1;
  if (first_call == 0) goto <D.7802>; else goto <D.7803>;
  <D.7802>:
  idx = idx + 1;
  <D.7803>:
  idx.12 = (void *) idx;
  *iter = idx.12;
  D.7728 = res;
  return D.7728;
}


mono_dl_fallback_register (void * (*MonoDlFallbackLoad) (const char *, int, char * *, void *) load_func, void * (*MonoDlFallbackSymbol) (void *, const char *, char * *, void *) symbol_func, void * (*MonoDlFallbackClose) (void *, void *) close_func, void * user_data)
{
  struct MonoDlFallbackHandler * D.7808;
  struct GSList * fallback_handlers.13;
  struct GSList * fallback_handlers.14;
  struct MonoDlFallbackHandler * handler;

  if (load_func == 0B) goto <D.7806>; else goto <D.7807>;
  <D.7806>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "mono-dl.c", 528, "load_func != NULL");
  D.7808 = 0B;
  return D.7808;
  <D.7807>:
  if (symbol_func == 0B) goto <D.7809>; else goto <D.7810>;
  <D.7809>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "mono-dl.c", 529, "symbol_func != NULL");
  D.7808 = 0B;
  return D.7808;
  <D.7810>:
  handler = monoeg_malloc (16);
  handler->load_func = load_func;
  handler->symbol_func = symbol_func;
  handler->close_func = close_func;
  handler->user_data = user_data;
  fallback_handlers.13 = fallback_handlers;
  fallback_handlers.14 = monoeg_g_slist_prepend (fallback_handlers.13, handler);
  fallback_handlers = fallback_handlers.14;
  D.7808 = handler;
  return D.7808;
}


mono_dl_fallback_unregister (struct MonoDlFallbackHandler * handler)
{
  struct GSList * fallback_handlers.15;
  struct GSList * found;

  fallback_handlers.15 = fallback_handlers;
  found = monoeg_g_slist_find (fallback_handlers.15, handler);
  if (found == 0B) goto <D.7815>; else goto <D.7816>;
  <D.7815>:
  return;
  <D.7816>:
  fallback_handlers.15 = fallback_handlers;
  monoeg_g_slist_remove (fallback_handlers.15, handler);
  monoeg_g_free (handler);
}