mono_attach_parse_options (char * options)
{
  int D.18030;
  int iftmp.0;
  int D.18029;
  const char[8] * D.18120;
  unsigned char D.18121;
  int D.18122;
  unsigned char D.18123;
  int D.18124;
  _Bool D.18125;
  _Bool D.18126;
  _Bool D.18127;
  const unsigned char * D.18130;
  unsigned char D.18131;
  int D.18132;
  const unsigned char * D.18133;
  unsigned char D.18134;
  int D.18135;
  _Bool D.18136;
  _Bool D.18137;
  const unsigned char * D.18140;
  unsigned char D.18141;
  int D.18142;
  const unsigned char * D.18143;
  unsigned char D.18144;
  int D.18145;
  _Bool D.18146;
  _Bool D.18147;
  const unsigned char * D.18150;
  unsigned char D.18151;
  int D.18152;
  const unsigned char * D.18153;
  unsigned char D.18154;
  int D.18155;

  if (options == 0B) goto <D.18115>; else goto <D.18116>;
  <D.18115>:
  return;
  <D.18116>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = options;
      D.18120 = "disable";
      D.18121 = MEM[(const unsigned char *)D.18120];
      D.18122 = (int) D.18121;
      D.18123 = *__s2;
      D.18124 = (int) D.18123;
      __result = D.18122 - D.18124;
      {
        D.18125 = __s2_len != 0;
        D.18126 = __result == 0;
        D.18127 = D.18125 & D.18126;
        if (D.18127 != 0) goto <D.18128>; else goto <D.18129>;
        <D.18128>:
        D.18130 = &MEM[(void *)"disable" + 1B];
        D.18131 = *D.18130;
        D.18132 = (int) D.18131;
        D.18133 = __s2 + 1;
        D.18134 = *D.18133;
        D.18135 = (int) D.18134;
        __result = D.18132 - D.18135;
        D.18136 = __s2_len > 1;
        D.18126 = __result == 0;
        D.18137 = D.18136 & D.18126;
        if (D.18137 != 0) goto <D.18138>; else goto <D.18139>;
        <D.18138>:
        D.18140 = &MEM[(void *)"disable" + 2B];
        D.18141 = *D.18140;
        D.18142 = (int) D.18141;
        D.18143 = __s2 + 2;
        D.18144 = *D.18143;
        D.18145 = (int) D.18144;
        __result = D.18142 - D.18145;
        D.18146 = __s2_len > 2;
        D.18126 = __result == 0;
        D.18147 = D.18146 & D.18126;
        if (D.18147 != 0) goto <D.18148>; else goto <D.18149>;
        <D.18148>:
        D.18150 = &MEM[(void *)"disable" + 3B];
        D.18151 = *D.18150;
        D.18152 = (int) D.18151;
        D.18153 = __s2 + 3;
        D.18154 = *D.18153;
        D.18155 = (int) D.18154;
        __result = D.18152 - D.18155;
        <D.18149>:
        <D.18139>:
        <D.18129>:
      }
      D.18029 = __result;
    }
    iftmp.0 = -D.18029;
    goto <D.18156>;
    <D.18119>:
    iftmp.0 = __builtin_strcmp (options, "disable");
    <D.18156>:
    D.18030 = iftmp.0;
  }
  if (D.18030 == 0) goto <D.18157>; else goto <D.18158>;
  <D.18157>:
  config.enabled = 0;
  <D.18158>:
}


mono_attach_init ()
{
  InitializeCriticalSection (&agent_mutex);
  config.enabled = 1;
}


mono_attach_start ()
{
  int started.1;
  gboolean D.18163;
  int D.18164;
  int D.18167;
  char path[256];
  int fd;

  try
    {
      started.1 = started;
      if (started.1 != 0) goto <D.18161>; else goto <D.18162>;
      <D.18161>:
      D.18163 = 0;
      return D.18163;
      <D.18162>:
      D.18164 = getpid ();
      snprintf (&path, 256, "/tmp/.mono_attach_pid%d", D.18164);
      fd = open (&path, 0);
      if (fd == -1) goto <D.18165>; else goto <D.18166>;
      <D.18165>:
      D.18163 = 0;
      return D.18163;
      <D.18166>:
      close (fd);
      D.18167 = config.enabled;
      if (D.18167 == 0) goto <D.18168>; else goto <D.18169>;
      <D.18168>:
      D.18163 = 1;
      return D.18163;
      <D.18169>:
      started.1 = started;
      if (started.1 != 0) goto <D.18170>; else goto <D.18171>;
      <D.18170>:
      D.18163 = 0;
      return D.18163;
      <D.18171>:
      needs_to_start = 1;
      mono_gc_finalize_notify ();
      D.18163 = 1;
      return D.18163;
    }
  finally
    {
      path = {CLOBBER};
    }
}


snprintf (char * restrict __s, size_t __n, const char * restrict __fmt)
{
  int D.18174;
  long unsigned int D.18175;

  D.18175 = __builtin_object_size (__s, 1);
  D.18174 = __builtin___snprintf_chk (__s, __n, 1, D.18175, __fmt, __builtin_va_arg_pack ());
  return D.18174;
}


open (const char * __path, int __oflag)
{
  int D.18177;
  int D.18180;
  int D.18185;
  int D.18187;
  int D.18188;
  int D.18191;
  int D.18192;

  D.18177 = __builtin_va_arg_pack_len ();
  if (D.18177 > 1) goto <D.18178>; else goto <D.18179>;
  <D.18178>:
  __open_too_many_args ();
  <D.18179>:
  D.18180 = __builtin_constant_p (__oflag);
  if (D.18180 != 0) goto <D.18181>; else goto <D.18182>;
  <D.18181>:
  D.18185 = __oflag & 64;
  if (D.18185 != 0) goto <D.18183>; else goto <D.18186>;
  <D.18186>:
  D.18187 = __oflag & 4259840;
  if (D.18187 == 4259840) goto <D.18183>; else goto <D.18184>;
  <D.18183>:
  D.18188 = __builtin_va_arg_pack_len ();
  if (D.18188 <= 0) goto <D.18189>; else goto <D.18190>;
  <D.18189>:
  __open_missing_mode ();
  D.18191 = __open_2 (__path, __oflag);
  return D.18191;
  <D.18190>:
  <D.18184>:
  D.18191 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.18191;
  <D.18182>:
  D.18192 = __builtin_va_arg_pack_len ();
  if (D.18192 <= 0) goto <D.18193>; else goto <D.18194>;
  <D.18193>:
  D.18191 = __open_2 (__path, __oflag);
  return D.18191;
  <D.18194>:
  D.18191 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.18191;
}


mono_attach_maybe_start ()
{
  int needs_to_start.2;
  int started.3;

  needs_to_start.2 = needs_to_start;
  if (needs_to_start.2 == 0) goto <D.18197>; else goto <D.18198>;
  <D.18197>:
  return;
  <D.18198>:
  needs_to_start = 0;
  started.3 = started;
  if (started.3 == 0) goto <D.18200>; else goto <D.18201>;
  <D.18200>:
  transport_start_receive ();
  started = 1;
  <D.18201>:
}


transport_start_receive ()
{
  int listen_fd.4;
  void * receiver_thread_handle.5;
  void * receiver_thread_handle.6;
  _Bool D.18208;
  long int D.18209;
  long int D.18210;

  transport_connect ();
  listen_fd.4 = listen_fd;
  if (listen_fd.4 == 0) goto <D.18204>; else goto <D.18205>;
  <D.18204>:
  return;
  <D.18205>:
  receiver_thread_handle.5 = mono_threads_create_thread (receiver_thread, 0B, 0, 0, 0B);
  receiver_thread_handle = receiver_thread_handle.5;
  receiver_thread_handle.6 = receiver_thread_handle;
  D.18208 = receiver_thread_handle.6 == 0B;
  D.18209 = (long int) D.18208;
  D.18210 = __builtin_expect (D.18209, 0);
  if (D.18210 != 0) goto <D.18211>; else goto <D.18212>;
  <D.18211>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 482, "receiver_thread_handle");
  <D.18212>:
}


receiver_thread (void * arg)
{
  char * server_uri.7;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.18215;
  int listen_fd.8;
  int conn_fd.9;
  int conn_fd.10;
  guint32 D.18221;
  struct MonoDomain * D.18222;
  struct MonoInternalThread * D.18223;
  unsigned int D.18224;
  unsigned int D.18225;
  long int D.18226;
  int * D.18229;
  int D.18230;
  int stop_receiver_thread.11;
  int D.18239;
  unsigned char D.18241;
  unsigned char D.18243;
  struct _IO_FILE * stderr.12;
  long int D.18245;
  guint8 * p.13;
  long unsigned int D.18248;
  long unsigned int D.18249;
  long int D.18250;
  sizetype D.18251;
  int D.18110;
  int iftmp.14;
  int D.18109;
  const char[7] * D.18256;
  unsigned char D.18257;
  int D.18258;
  unsigned char D.18259;
  int D.18260;
  _Bool D.18261;
  _Bool D.18262;
  _Bool D.18263;
  const unsigned char * D.18266;
  unsigned char D.18267;
  int D.18268;
  const unsigned char * D.18269;
  unsigned char D.18270;
  int D.18271;
  _Bool D.18272;
  _Bool D.18273;
  const unsigned char * D.18276;
  unsigned char D.18277;
  int D.18278;
  const unsigned char * D.18279;
  unsigned char D.18280;
  int D.18281;
  _Bool D.18282;
  _Bool D.18283;
  const unsigned char * D.18286;
  unsigned char D.18287;
  int D.18288;
  const unsigned char * D.18289;
  unsigned char D.18290;
  int D.18291;
  _Bool D.18293;
  long int D.18294;
  long int D.18295;
  struct MonoDomain * D.18298;
  int res;
  int content_len;
  guint8 buffer[256];
  guint8 * p;
  guint8 * p_end;
  struct MonoObject * exc;

  try
    {
      server_uri.7 = server_uri;
      printf ("attach: Listening on \'%s\'...\n", server_uri.7);
      <D.18113>:
      D.18215.__sockaddr__ = 0B;
      listen_fd.8 = listen_fd;
      conn_fd.9 = accept (listen_fd.8, D.18215, 0B);
      conn_fd = conn_fd.9;
      conn_fd.10 = conn_fd;
      if (conn_fd.10 == -1) goto <D.18219>; else goto <D.18220>;
      <D.18219>:
      D.18221 = 0;
      return D.18221;
      <D.18220>:
      printf ("attach: Connected.\n");
      D.18222 = mono_get_root_domain ();
      mono_thread_attach (D.18222);
      D.18223 = mono_thread_internal_current ();
      D.18224 = D.18223->state;
      D.18225 = D.18224 | 4;
      D.18223->state = D.18225;
      <D.18111>:
      {
        char * cmd;
        char * agent_name;
        char * agent_args;
        guint8 * body;

        conn_fd.10 = conn_fd;
        D.18226 = read (conn_fd.10, &buffer, 6);
        res = (int) D.18226;
        if (res == -1) goto <D.18227>; else goto <D.18228>;
        <D.18227>:
        D.18229 = __errno_location ();
        D.18230 = *D.18229;
        if (D.18230 == 4) goto <D.18231>; else goto <D.18232>;
        <D.18231>:
        // predicted unlikely by continue predictor.
        goto <D.18091>;
        <D.18232>:
        <D.18228>:
        if (res == -1) goto <D.18092>; else goto <D.18233>;
        <D.18233>:
        stop_receiver_thread.11 = stop_receiver_thread;
        if (stop_receiver_thread.11 != 0) goto <D.18092>; else goto <D.18235>;
        <D.18235>:
        if (res != 6) goto <D.18092>; else goto <D.18236>;
        <D.18236>:
        D.18239 = strncmp (&buffer, "MONO", 4);
        if (D.18239 != 0) goto <D.18237>; else goto <D.18240>;
        <D.18240>:
        D.18241 = buffer[4];
        if (D.18241 != 1) goto <D.18237>; else goto <D.18242>;
        <D.18242>:
        D.18243 = buffer[5];
        if (D.18243 != 0) goto <D.18237>; else goto <D.18238>;
        <D.18237>:
        stderr.12 = stderr;
        fprintf (stderr.12, "attach: message from server has unknown header.\n");
        goto <D.18092>;
        <D.18238>:
        conn_fd.10 = conn_fd;
        D.18245 = read (conn_fd.10, &buffer, 4);
        res = (int) D.18245;
        if (res != 4) goto <D.18092>; else goto <D.18246>;
        <D.18246>:
        p = &buffer;
        p.13 = p;
        p_end = p.13 + 8;
        p.13 = p;
        content_len = decode_int (p.13, &p, p_end);
        D.18248 = (long unsigned int) content_len;
        body = monoeg_malloc (D.18248);
        D.18249 = (long unsigned int) content_len;
        conn_fd.10 = conn_fd;
        D.18250 = read (conn_fd.10, body, D.18249);
        res = (int) D.18250;
        p = body;
        D.18251 = (sizetype) content_len;
        p_end = body + D.18251;
        p.13 = p;
        cmd = decode_string_value (p.13, &p, p_end);
        if (cmd == 0B) goto <D.18092>; else goto <D.18252>;
        <D.18252>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = cmd;
            D.18256 = "attach";
            D.18257 = MEM[(const unsigned char *)D.18256];
            D.18258 = (int) D.18257;
            D.18259 = *__s2;
            D.18260 = (int) D.18259;
            __result = D.18258 - D.18260;
            {
              D.18261 = __s2_len != 0;
              D.18262 = __result == 0;
              D.18263 = D.18261 & D.18262;
              if (D.18263 != 0) goto <D.18264>; else goto <D.18265>;
              <D.18264>:
              D.18266 = &MEM[(void *)"attach" + 1B];
              D.18267 = *D.18266;
              D.18268 = (int) D.18267;
              D.18269 = __s2 + 1;
              D.18270 = *D.18269;
              D.18271 = (int) D.18270;
              __result = D.18268 - D.18271;
              D.18272 = __s2_len > 1;
              D.18262 = __result == 0;
              D.18273 = D.18272 & D.18262;
              if (D.18273 != 0) goto <D.18274>; else goto <D.18275>;
              <D.18274>:
              D.18276 = &MEM[(void *)"attach" + 2B];
              D.18277 = *D.18276;
              D.18278 = (int) D.18277;
              D.18279 = __s2 + 2;
              D.18280 = *D.18279;
              D.18281 = (int) D.18280;
              __result = D.18278 - D.18281;
              D.18282 = __s2_len > 2;
              D.18262 = __result == 0;
              D.18283 = D.18282 & D.18262;
              if (D.18283 != 0) goto <D.18284>; else goto <D.18285>;
              <D.18284>:
              D.18286 = &MEM[(void *)"attach" + 3B];
              D.18287 = *D.18286;
              D.18288 = (int) D.18287;
              D.18289 = __s2 + 3;
              D.18290 = *D.18289;
              D.18291 = (int) D.18290;
              __result = D.18288 - D.18291;
              <D.18285>:
              <D.18275>:
              <D.18265>:
            }
            D.18109 = __result;
          }
          iftmp.14 = -D.18109;
          goto <D.18292>;
          <D.18255>:
          iftmp.14 = __builtin_strcmp (cmd, "attach");
          <D.18292>:
          D.18110 = iftmp.14;
        }
        D.18293 = D.18110 != 0;
        D.18294 = (long int) D.18293;
        D.18295 = __builtin_expect (D.18294, 0);
        if (D.18295 != 0) goto <D.18296>; else goto <D.18297>;
        <D.18296>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 550, "!strcmp (cmd, \"attach\")");
        <D.18297>:
        p.13 = p;
        agent_name = decode_string_value (p.13, &p, p_end);
        p.13 = p;
        agent_args = decode_string_value (p.13, &p, p_end);
        printf ("attach: Loading agent \'%s\'.\n", agent_name);
        D.18298 = mono_domain_get ();
        mono_attach_load_agent (D.18298, agent_name, agent_args, &exc);
        monoeg_g_free (body);
      }
      <D.18091>:
      goto <D.18111>;
      <D.18092>:
      conn_fd.10 = conn_fd;
      close (conn_fd.10);
      conn_fd = 0;
      printf ("attach: Disconnected.\n");
      stop_receiver_thread.11 = stop_receiver_thread;
      if (stop_receiver_thread.11 != 0) goto <D.18112>; else goto <D.18299>;
      <D.18299>:
      goto <D.18113>;
      <D.18112>:
      D.18221 = 0;
      return D.18221;
    }
  finally
    {
      buffer = {CLOBBER};
      p = {CLOBBER};
      exc = {CLOBBER};
    }
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.18302;

  D.18302 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.18302;
}


decode_int (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.18304;
  guint8 * D.18305;
  _Bool D.18306;
  long int D.18307;
  long int D.18308;
  int D.18311;
  unsigned char D.18312;
  int D.18313;
  guint8 * D.18314;
  unsigned char D.18315;
  int D.18316;
  int D.18317;
  int D.18318;
  guint8 * D.18319;
  unsigned char D.18320;
  int D.18321;
  int D.18322;
  int D.18323;
  guint8 * D.18324;
  unsigned char D.18325;
  int D.18326;
  int D.18327;

  D.18304 = buf + 4;
  *endbuf = D.18304;
  D.18305 = *endbuf;
  D.18306 = D.18305 > limit;
  D.18307 = (long int) D.18306;
  D.18308 = __builtin_expect (D.18307, 0);
  if (D.18308 != 0) goto <D.18309>; else goto <D.18310>;
  <D.18309>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 126, "*endbuf <= limit");
  <D.18310>:
  D.18312 = *buf;
  D.18313 = (int) D.18312;
  D.18314 = buf + 1;
  D.18315 = *D.18314;
  D.18316 = (int) D.18315;
  D.18317 = D.18316 << 8;
  D.18318 = D.18313 | D.18317;
  D.18319 = buf + 2;
  D.18320 = *D.18319;
  D.18321 = (int) D.18320;
  D.18322 = D.18321 << 16;
  D.18323 = D.18318 | D.18322;
  D.18324 = buf + 3;
  D.18325 = *D.18324;
  D.18326 = (int) D.18325;
  D.18327 = D.18326 << 24;
  D.18311 = D.18323 | D.18327;
  return D.18311;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.18329;
  int D.18332;
  ssize_t D.18335;
  long unsigned int D.18336;
  long unsigned int D.18337;
  long unsigned int D.18340;

  D.18329 = __builtin_object_size (__buf, 0);
  if (D.18329 != 18446744073709551615) goto <D.18330>; else goto <D.18331>;
  <D.18330>:
  D.18332 = __builtin_constant_p (__nbytes);
  if (D.18332 == 0) goto <D.18333>; else goto <D.18334>;
  <D.18333>:
  D.18336 = __builtin_object_size (__buf, 0);
  D.18335 = __read_chk (__fd, __buf, __nbytes, D.18336);
  return D.18335;
  <D.18334>:
  D.18337 = __builtin_object_size (__buf, 0);
  if (D.18337 < __nbytes) goto <D.18338>; else goto <D.18339>;
  <D.18338>:
  D.18340 = __builtin_object_size (__buf, 0);
  D.18335 = __read_chk_warn (__fd, __buf, __nbytes, D.18340);
  return D.18335;
  <D.18339>:
  <D.18331>:
  D.18335 = __read_alias (__fd, __buf, __nbytes);
  return D.18335;
}


decode_string_value (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * p.15;
  char * D.18345;
  _Bool D.18346;
  long int D.18347;
  long int D.18348;
  int D.18351;
  int D.18352;
  signed char b.16;
  _Bool D.18355;
  long int D.18356;
  long int D.18357;
  int D.18360;
  long unsigned int D.18361;
  sizetype D.18362;
  guint8 * p.17;
  _Bool D.18364;
  long int D.18365;
  long int D.18366;
  long unsigned int D.18369;
  char * D.18370;
  int type;
  gint32 length;
  guint8 * p;
  char * s;

  try
    {
      p = buf;
      p.15 = p;
      type = decode_byte (p.15, &p, limit);
      if (type == 17) goto <D.18343>; else goto <D.18344>;
      <D.18343>:
      p.15 = p;
      *endbuf = p.15;
      D.18345 = 0B;
      return D.18345;
      <D.18344>:
      D.18346 = type != 18;
      D.18347 = (long int) D.18346;
      D.18348 = __builtin_expect (D.18347, 0);
      if (D.18348 != 0) goto <D.18349>; else goto <D.18350>;
      <D.18349>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 153, "type == PRIM_TYPE_STRING");
      <D.18350>:
      length = 0;
      <D.18018>:
      {
        guint8 b;

        p.15 = p;
        D.18351 = decode_byte (p.15, &p, limit);
        b = (guint8) D.18351;
        length = length << 8;
        D.18352 = (int) b;
        length = D.18352 + length;
        b.16 = (signed char) b;
        if (b.16 >= 0) goto <D.18017>; else goto <D.18354>;
        <D.18354>:
      }
      goto <D.18018>;
      <D.18017>:
      D.18355 = length > 65535;
      D.18356 = (long int) D.18355;
      D.18357 = __builtin_expect (D.18356, 0);
      if (D.18357 != 0) goto <D.18358>; else goto <D.18359>;
      <D.18358>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 165, "length < (1 << 16)");
      <D.18359>:
      D.18360 = length + 1;
      D.18361 = (long unsigned int) D.18360;
      s = monoeg_malloc (D.18361);
      p.15 = p;
      D.18362 = (sizetype) length;
      p.17 = p.15 + D.18362;
      D.18364 = p.17 > limit;
      D.18365 = (long int) D.18364;
      D.18366 = __builtin_expect (D.18365, 0);
      if (D.18366 != 0) goto <D.18367>; else goto <D.18368>;
      <D.18367>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 169, "p + length <= limit");
      <D.18368>:
      D.18369 = (long unsigned int) length;
      p.15 = p;
      memcpy (s, p.15, D.18369);
      D.18362 = (sizetype) length;
      D.18370 = s + D.18362;
      *D.18370 = 0;
      p.15 = p;
      D.18362 = (sizetype) length;
      p.17 = p.15 + D.18362;
      p = p.17;
      p.15 = p;
      *endbuf = p.15;
      D.18345 = s;
      return D.18345;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_byte (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.18373;
  guint8 * D.18374;
  _Bool D.18375;
  long int D.18376;
  long int D.18377;
  int D.18380;
  unsigned char D.18381;

  D.18373 = buf + 1;
  *endbuf = D.18373;
  D.18374 = *endbuf;
  D.18375 = D.18374 > limit;
  D.18376 = (long int) D.18375;
  D.18377 = __builtin_expect (D.18376, 0);
  if (D.18377 != 0) goto <D.18378>; else goto <D.18379>;
  <D.18378>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 118, "*endbuf <= limit");
  <D.18379>:
  D.18381 = *buf;
  D.18380 = (int) D.18381;
  return D.18380;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.18383;
  long unsigned int D.18384;

  D.18384 = __builtin_object_size (__dest, 0);
  D.18383 = __builtin___memcpy_chk (__dest, __src, __len, D.18384);
  return D.18383;
}


mono_attach_load_agent (struct MonoDomain * domain, char * agent, char * args, struct MonoObject * * exc)
{
  <unnamed type> open_status.18;
  const char * D.18389;
  struct _IO_FILE * stderr.19;
  int D.18391;
  const char * D.18394;
  struct MonoClass * D.18399;
  struct MonoString * D.18400;
  struct MonoAssembly * agent_assembly;
  struct MonoImage * image;
  struct MonoMethod * method;
  guint32 entry;
  struct MonoArray * main_args;
  void * pa[1];
  MonoImageOpenStatus open_status;

  try
    {
      agent_assembly = mono_assembly_open (agent, &open_status);
      if (agent_assembly == 0B) goto <D.18386>; else goto <D.18387>;
      <D.18386>:
      open_status.18 = open_status;
      D.18389 = mono_image_strerror (open_status.18);
      stderr.19 = stderr;
      fprintf (stderr.19, "Cannot open agent assembly \'%s\': %s.\n", agent, D.18389);
      monoeg_g_free (agent);
      D.18391 = 2;
      return D.18391;
      <D.18387>:
      image = mono_assembly_get_image (agent_assembly);
      entry = mono_image_get_entry_point (image);
      if (entry == 0) goto <D.18392>; else goto <D.18393>;
      <D.18392>:
      D.18394 = mono_image_get_filename (image);
      monoeg_g_print ("Assembly \'%s\' doesn\'t have an entry point.\n", D.18394);
      monoeg_g_free (agent);
      D.18391 = 1;
      return D.18391;
      <D.18393>:
      method = mono_get_method (image, entry, 0B);
      if (method == 0B) goto <D.18395>; else goto <D.18396>;
      <D.18395>:
      monoeg_g_print ("The entry point method of assembly \'%s\' could not be loaded\n", agent);
      monoeg_g_free (agent);
      D.18391 = 1;
      return D.18391;
      <D.18396>:
      if (args != 0B) goto <D.18397>; else goto <D.18398>;
      <D.18397>:
      D.18399 = mono_defaults.string_class;
      main_args = mono_array_new (domain, D.18399, 1);
      {
        struct MonoString * * __p;

        __p = mono_array_addr_with_size (main_args, 8, 0);
        D.18400 = mono_string_new (domain, args);
        *__p = D.18400;
      }
      goto <D.18401>;
      <D.18398>:
      D.18399 = mono_defaults.string_class;
      main_args = mono_array_new (domain, D.18399, 0);
      <D.18401>:
      monoeg_g_free (agent);
      pa[0] = main_args;
      mono_runtime_invoke (method, 0B, &pa, exc);
      D.18391 = 0;
      return D.18391;
    }
  finally
    {
      pa = {CLOBBER};
      open_status = {CLOBBER};
    }
}


printf (const char * restrict __fmt)
{
  int D.18404;

  D.18404 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.18404;
}


transport_connect ()
{
  ipc_connect ();
}


ipc_connect ()
{
  unsigned int D.18406;
  unsigned int D.18407;
  struct _IO_FILE * stderr.20;
  unsigned int D.18413;
  struct passwd * pw.21;
  _Bool D.18417;
  long int D.18418;
  long int D.18419;
  char * D.18422;
  int * D.18425;
  int D.18426;
  unsigned int D.18431;
  unsigned int D.18432;
  unsigned int D.18435;
  unsigned int D.18436;
  unsigned int D.18439;
  unsigned int D.18440;
  int D.18444;
  long unsigned int D.18445;
  unsigned int D.18446;
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.18447;
  int D.18448;
  char * D.18451;
  char * D.18456;
  gchar * ipc_filename.22;
  int D.18458;
  gchar * server_uri.23;
  struct sockaddr_un name;
  int sock;
  int res;
  size_t size;
  char * filename;
  char * directory;
  struct stat stat;
  struct passwd pwbuf;
  char buf[1024];
  struct passwd * pw;

  try
    {
      D.18406 = getuid ();
      D.18407 = geteuid ();
      if (D.18406 != D.18407) goto <D.18408>; else goto <D.18409>;
      <D.18408>:
      stderr.20 = stderr;
      fprintf (stderr.20, "attach: disabled listening on an IPC socket when running in setuid mode.\n");
      return;
      <D.18409>:
      sock = socket (1, 1, 0);
      if (sock < 0) goto <D.18411>; else goto <D.18412>;
      <D.18411>:
      perror ("attach: failed to create IPC socket");
      return;
      <D.18412>:
      pw = 0B;
      D.18413 = getuid ();
      res = getpwuid_r (D.18413, &pwbuf, &buf, 1024, &pw);
      if (res != 0) goto <D.18414>; else goto <D.18415>;
      <D.18414>:
      stderr.20 = stderr;
      fprintf (stderr.20, "attach: getpwuid_r () failed.\n");
      return;
      <D.18415>:
      pw.21 = pw;
      D.18417 = pw.21 == 0B;
      D.18418 = (long int) D.18417;
      D.18419 = __builtin_expect (D.18418, 0);
      if (D.18419 != 0) goto <D.18420>; else goto <D.18421>;
      <D.18420>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "attach.c", 379, "pw");
      <D.18421>:
      pw.21 = pw;
      D.18422 = pw.21->pw_name;
      directory = monoeg_g_strdup_printf ("/tmp/mono-%s", D.18422);
      res = mkdir (directory, 448);
      if (res != 0) goto <D.18423>; else goto <D.18424>;
      <D.18423>:
      D.18425 = __errno_location ();
      D.18426 = *D.18425;
      if (D.18426 == 17) goto <D.18427>; else goto <D.18428>;
      <D.18427>:
      res = lstat (directory, &stat);
      if (res != 0) goto <D.18429>; else goto <D.18430>;
      <D.18429>:
      perror ("attach: lstat () failed");
      return;
      <D.18430>:
      D.18431 = stat.st_mode;
      D.18432 = D.18431 & 61440;
      if (D.18432 != 16384) goto <D.18433>; else goto <D.18434>;
      <D.18433>:
      stderr.20 = stderr;
      fprintf (stderr.20, "attach: path \'%s\' is not a directory.\n", directory);
      return;
      <D.18434>:
      D.18435 = stat.st_uid;
      D.18436 = getuid ();
      if (D.18435 != D.18436) goto <D.18437>; else goto <D.18438>;
      <D.18437>:
      stderr.20 = stderr;
      fprintf (stderr.20, "attach: directory \'%s\' is not owned by the current user.\n", directory);
      return;
      <D.18438>:
      D.18439 = BIT_FIELD_REF <stat, 32, 192>;
      D.18440 = D.18439 & 511;
      if (D.18440 != 448) goto <D.18441>; else goto <D.18442>;
      <D.18441>:
      stderr.20 = stderr;
      fprintf (stderr.20, "attach: directory \'%s\' should have protection 0700.\n", directory);
      return;
      <D.18442>:
      goto <D.18443>;
      <D.18428>:
      perror ("attach: mkdir () failed");
      return;
      <D.18443>:
      <D.18424>:
      D.18444 = getpid ();
      filename = monoeg_g_strdup_printf ("%s/.mono-%d", directory, D.18444);
      unlink (filename);
      name.sun_family = 1;
      strcpy (&name.sun_path, filename);
      D.18445 = strlen (&name.sun_path);
      size = D.18445 + 3;
      D.18446 = (unsigned int) size;
      D.18447.__sockaddr__ = &name;
      D.18448 = bind (sock, D.18447, D.18446);
      if (D.18448 < 0) goto <D.18449>; else goto <D.18450>;
      <D.18449>:
      D.18425 = __errno_location ();
      D.18426 = *D.18425;
      D.18451 = strerror (D.18426);
      stderr.20 = stderr;
      fprintf (stderr.20, "attach: failed to bind IPC socket \'%s\': %s\n", filename, D.18451);
      close (sock);
      return;
      <D.18450>:
      res = chmod (filename, 384);
      if (res != 0) goto <D.18452>; else goto <D.18453>;
      <D.18452>:
      perror ("attach: failed to set permissions on IPC socket");
      close (sock);
      unlink (filename);
      return;
      <D.18453>:
      res = listen (sock, 16);
      if (res != 0) goto <D.18454>; else goto <D.18455>;
      <D.18454>:
      D.18425 = __errno_location ();
      D.18426 = *D.18425;
      D.18456 = strerror (D.18426);
      stderr.20 = stderr;
      fprintf (stderr.20, "attach: listen () failed: %s\n", D.18456);
      exit (1);
      <D.18455>:
      listen_fd = sock;
      ipc_filename.22 = monoeg_strdup (filename);
      ipc_filename = ipc_filename.22;
      D.18458 = getpid ();
      server_uri.23 = monoeg_g_strdup_printf ("unix://%s/.mono-%d?/vm", directory, D.18458);
      server_uri = server_uri.23;
      monoeg_g_free (filename);
      monoeg_g_free (directory);
    }
  finally
    {
      name = {CLOBBER};
      stat = {CLOBBER};
      pwbuf = {CLOBBER};
      buf = {CLOBBER};
      pw = {CLOBBER};
    }
}


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

  D.18463 = __lxstat (1, __path, __statbuf);
  return D.18463;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.18465;
  long unsigned int D.18466;

  D.18466 = __builtin_object_size (__dest, 1);
  D.18465 = __builtin___strcpy_chk (__dest, __src, D.18466);
  return D.18465;
}


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

  if (str != 0B) goto <D.18468>; else goto <D.18469>;
  <D.18468>:
  D.18470 = __strdup (str);
  return D.18470;
  <D.18469>:
  D.18470 = 0B;
  return D.18470;
}


mono_attach_cleanup ()
{
  int listen_fd.24;
  char * ipc_filename.25;
  int conn_fd.26;
  void * receiver_thread_handle.27;

  listen_fd.24 = listen_fd;
  if (listen_fd.24 != 0) goto <D.18473>; else goto <D.18474>;
  <D.18473>:
  listen_fd.24 = listen_fd;
  close (listen_fd.24);
  <D.18474>:
  ipc_filename.25 = ipc_filename;
  if (ipc_filename.25 != 0B) goto <D.18476>; else goto <D.18477>;
  <D.18476>:
  ipc_filename.25 = ipc_filename;
  unlink (ipc_filename.25);
  <D.18477>:
  stop_receiver_thread = 1;
  conn_fd.26 = conn_fd;
  if (conn_fd.26 != 0) goto <D.18479>; else goto <D.18480>;
  <D.18479>:
  conn_fd.26 = conn_fd;
  close (conn_fd.26);
  <D.18480>:
  receiver_thread_handle.27 = receiver_thread_handle;
  if (receiver_thread_handle.27 != 0B) goto <D.18482>; else goto <D.18483>;
  <D.18482>:
  receiver_thread_handle.27 = receiver_thread_handle;
  WaitForSingleObjectEx (receiver_thread_handle.27, 0, 0);
  <D.18483>:
}