ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid)
{
  void * D.16404;
  void * handle;

  handle = OpenProcess (2035711, 1, pid);
  if (handle == 0B) goto <D.16402>; else goto <D.16403>;
  <D.16402>:
  D.16404 = 0B;
  return D.16404;
  <D.16403>:
  D.16404 = handle;
  return D.16404;
}


ves_icall_System_Diagnostics_Process_GetPid_internal ()
{
  guint32 D.16406;

  D.16406 = GetCurrentProcessId ();
  return D.16406;
}


ves_icall_System_Diagnostics_Process_Process_free_internal (struct MonoObject * this, void * process)
{
  CloseProcess (process);
}


ves_icall_System_Diagnostics_Process_GetModules_internal (struct MonoObject * this, void * process)
{
  struct MonoImage * system_assembly.0;
  struct MonoVTable * D.16411;
  struct MonoClass * D.16412;
  struct MonoImage * system_assembly.1;
  int D.16414;
  unsigned int needed.2;
  struct MonoDomain * D.16418;
  struct MonoClass * D.16419;
  void * D.16420;
  unsigned int D.16421;
  unsigned int D.16424;
  unsigned int num_added.3;
  struct MonoDomain * D.16431;
  struct MonoClass * D.16432;
  char * D.16433;
  struct MonoObject * D.16434;
  struct MonoArray * D.16435;
  struct MonoArray * temp_arr;
  struct MonoArray * arr;
  void * mods[1024];
  gunichar2 filename[260];
  gunichar2 modname[260];
  DWORD needed;
  guint32 count;
  guint32 i;
  guint32 num_added;

  try
    {
      temp_arr = 0B;
      count = 0;
      num_added = 0;
      system_assembly.0 = system_assembly;
      if (system_assembly.0 == 0B) goto <D.16409>; else goto <D.16410>;
      <D.16409>:
      D.16411 = this->vtable;
      D.16412 = D.16411->klass;
      system_assembly.1 = D.16412->image;
      system_assembly = system_assembly.1;
      <D.16410>:
      D.16414 = EnumProcessModules (process, &mods, 4096, &needed);
      if (D.16414 != 0) goto <D.16415>; else goto <D.16416>;
      <D.16415>:
      needed.2 = needed;
      count = needed.2 / 4;
      D.16418 = mono_domain_get ();
      D.16419 = mono_get_object_class ();
      temp_arr = mono_array_new (D.16418, D.16419, count);
      i = 0;
      goto <D.16232>;
      <D.16231>:
      D.16420 = mods[i];
      D.16421 = GetModuleBaseName (process, D.16420, &modname, 260);
      if (D.16421 != 0) goto <D.16422>; else goto <D.16423>;
      <D.16422>:
      D.16420 = mods[i];
      D.16424 = GetModuleFileNameEx (process, D.16420, &filename, 260);
      if (D.16424 != 0) goto <D.16425>; else goto <D.16426>;
      <D.16425>:
      {
        struct MonoObject * module;

        D.16420 = mods[i];
        module = process_add_module (process, D.16420, &filename, &modname);
        {
          void * * __p;

          num_added.3 = num_added;
          num_added = num_added.3 + 1;
          __p = mono_array_addr_with_size (temp_arr, 4, num_added.3);
          mono_gc_wbarrier_set_arrayref (temp_arr, __p, module);
        }
      }
      <D.16426>:
      <D.16423>:
      i = i + 1;
      <D.16232>:
      if (i < count) goto <D.16231>; else goto <D.16233>;
      <D.16233>:
      <D.16416>:
      if (count == num_added) goto <D.16428>; else goto <D.16429>;
      <D.16428>:
      arr = temp_arr;
      goto <D.16430>;
      <D.16429>:
      D.16431 = mono_domain_get ();
      D.16432 = mono_get_object_class ();
      arr = mono_array_new (D.16431, D.16432, num_added);
      i = 0;
      goto <D.16236>;
      <D.16235>:
      {
        void * * __p;

        __p = mono_array_addr_with_size (arr, 4, i);
        D.16433 = mono_array_addr_with_size (temp_arr, 4, i);
        D.16434 = MEM[(struct MonoObject * *)D.16433];
        mono_gc_wbarrier_set_arrayref (arr, __p, D.16434);
      }
      i = i + 1;
      <D.16236>:
      if (i < num_added) goto <D.16235>; else goto <D.16237>;
      <D.16237>:
      <D.16430>:
      D.16435 = arr;
      return D.16435;
    }
  finally
    {
      mods = {CLOBBER};
      filename = {CLOBBER};
      modname = {CLOBBER};
      needed = {CLOBBER};
    }
}


process_add_module (void * process, void * mod, gunichar2 * filename, gunichar2 * modulename)
{
  struct MonoImage * system_assembly.4;
  unsigned int D.16439;
  void * D.16442;
  void * D.16443;
  unsigned int D.16444;
  unsigned int D.16445;
  unsigned int D.16446;
  struct MonoObject * D.16447;
  struct MonoClass * proc_class;
  struct MonoClass * filever_class;
  struct MonoObject * item;
  struct MonoObject * filever;
  struct MonoDomain * domain;
  struct MODULEINFO modinfo;
  BOOL ok;

  try
    {
      domain = mono_domain_get ();
      system_assembly.4 = system_assembly;
      proc_class = mono_class_from_name (system_assembly.4, "System.Diagnostics", "ProcessModule");
      item = mono_object_new (domain, proc_class);
      system_assembly.4 = system_assembly;
      filever_class = mono_class_from_name (system_assembly.4, "System.Diagnostics", "FileVersionInfo");
      filever = mono_object_new (domain, filever_class);
      process_get_fileversion (filever, filename);
      D.16439 = unicode_chars (filename);
      process_set_field_string (filever, "filename", filename, D.16439);
      ok = GetModuleInformation (process, mod, &modinfo, 12);
      if (ok != 0) goto <D.16440>; else goto <D.16441>;
      <D.16440>:
      D.16442 = modinfo.lpBaseOfDll;
      process_set_field_intptr (item, "baseaddr", D.16442);
      D.16443 = modinfo.EntryPoint;
      process_set_field_intptr (item, "entryaddr", D.16443);
      D.16444 = modinfo.SizeOfImage;
      process_set_field_int (item, "memory_size", D.16444);
      <D.16441>:
      D.16445 = unicode_chars (filename);
      process_set_field_string (item, "filename", filename, D.16445);
      D.16446 = unicode_chars (modulename);
      process_set_field_string (item, "modulename", modulename, D.16446);
      process_set_field_object (item, "version_info", filever);
      D.16447 = item;
      return D.16447;
    }
  finally
    {
      modinfo = {CLOBBER};
    }
}


process_get_fileversion (struct MonoObject * filever, gunichar2 * filename)
{
  unsigned int verinfohandle.5;
  int D.16457;
  struct VS_FIXEDFILEINFO * ffi.6;
  unsigned int D.16461;
  unsigned int D.16462;
  short unsigned int D.16463;
  unsigned int D.16464;
  short unsigned int D.16465;
  unsigned int D.16466;
  unsigned int D.16467;
  unsigned int D.16468;
  short unsigned int D.16469;
  unsigned int D.16470;
  short unsigned int D.16471;
  unsigned int D.16472;
  unsigned int D.16473;
  unsigned int D.16474;
  short unsigned int D.16475;
  unsigned int D.16476;
  short unsigned int D.16477;
  unsigned int D.16478;
  unsigned int D.16479;
  unsigned int D.16480;
  short unsigned int D.16481;
  unsigned int D.16482;
  short unsigned int D.16483;
  unsigned int D.16484;
  unsigned int D.16485;
  unsigned int D.16486;
  unsigned int D.16487;
  int D.16488;
  int D.16489;
  int D.16490;
  int D.16491;
  int D.16492;
  int D.16493;
  int D.16496;
  unsigned int trans_size.7;
  guchar * trans_data.8;
  unsigned char D.16503;
  int D.16504;
  guchar * D.16505;
  unsigned char D.16506;
  int D.16507;
  int D.16508;
  int D.16509;
  guchar * D.16510;
  unsigned char D.16511;
  int D.16512;
  int D.16513;
  int D.16514;
  guchar * D.16515;
  unsigned char D.16516;
  int D.16517;
  int D.16518;
  int D.16519;
  unsigned int D.16520;
  DWORD verinfohandle;
  struct VS_FIXEDFILEINFO * ffi;
  void * data;
  DWORD datalen;
  guchar * trans_data;
  gunichar2 * query;
  UINT ffi_size;
  UINT trans_size;
  BOOL ok;
  gunichar2 lang_buf[128];
  guint32 lang;
  guint32 lang_count;

  try
    {
      datalen = GetFileVersionInfoSize (filename, &verinfohandle);
      if (datalen != 0) goto <D.16450>; else goto <D.16451>;
      <D.16450>:
      data = monoeg_malloc0 (datalen);
      verinfohandle.5 = verinfohandle;
      ok = GetFileVersionInfo (filename, verinfohandle.5, datalen, data);
      if (ok != 0) goto <D.16453>; else goto <D.16454>;
      <D.16453>:
      query = monoeg_g_utf8_to_utf16 ("\\", -1, 0B, 0B, 0B);
      if (query == 0B) goto <D.16455>; else goto <D.16456>;
      <D.16455>:
      monoeg_g_free (data);
      return;
      <D.16456>:
      D.16457 = VerQueryValue (data, query, &ffi, &ffi_size);
      if (D.16457 != 0) goto <D.16458>; else goto <D.16459>;
      <D.16458>:
      ffi.6 = ffi;
      D.16461 = ffi.6->dwFileVersionMS;
      D.16462 = D.16461 >> 16;
      D.16463 = (short unsigned int) D.16462;
      D.16464 = (unsigned int) D.16463;
      process_set_field_int (filever, "filemajorpart", D.16464);
      ffi.6 = ffi;
      D.16461 = ffi.6->dwFileVersionMS;
      D.16465 = (short unsigned int) D.16461;
      D.16466 = (unsigned int) D.16465;
      process_set_field_int (filever, "fileminorpart", D.16466);
      ffi.6 = ffi;
      D.16467 = ffi.6->dwFileVersionLS;
      D.16468 = D.16467 >> 16;
      D.16469 = (short unsigned int) D.16468;
      D.16470 = (unsigned int) D.16469;
      process_set_field_int (filever, "filebuildpart", D.16470);
      ffi.6 = ffi;
      D.16467 = ffi.6->dwFileVersionLS;
      D.16471 = (short unsigned int) D.16467;
      D.16472 = (unsigned int) D.16471;
      process_set_field_int (filever, "fileprivatepart", D.16472);
      ffi.6 = ffi;
      D.16473 = ffi.6->dwProductVersionMS;
      D.16474 = D.16473 >> 16;
      D.16475 = (short unsigned int) D.16474;
      D.16476 = (unsigned int) D.16475;
      process_set_field_int (filever, "productmajorpart", D.16476);
      ffi.6 = ffi;
      D.16473 = ffi.6->dwProductVersionMS;
      D.16477 = (short unsigned int) D.16473;
      D.16478 = (unsigned int) D.16477;
      process_set_field_int (filever, "productminorpart", D.16478);
      ffi.6 = ffi;
      D.16479 = ffi.6->dwProductVersionLS;
      D.16480 = D.16479 >> 16;
      D.16481 = (short unsigned int) D.16480;
      D.16482 = (unsigned int) D.16481;
      process_set_field_int (filever, "productbuildpart", D.16482);
      ffi.6 = ffi;
      D.16479 = ffi.6->dwProductVersionLS;
      D.16483 = (short unsigned int) D.16479;
      D.16484 = (unsigned int) D.16483;
      process_set_field_int (filever, "productprivatepart", D.16484);
      ffi.6 = ffi;
      D.16485 = ffi.6->dwFileFlags;
      ffi.6 = ffi;
      D.16486 = ffi.6->dwFileFlagsMask;
      D.16487 = D.16485 & D.16486;
      D.16488 = (int) D.16487;
      D.16489 = D.16488 & 1;
      process_set_field_bool (filever, "isdebug", D.16489);
      ffi.6 = ffi;
      D.16485 = ffi.6->dwFileFlags;
      ffi.6 = ffi;
      D.16486 = ffi.6->dwFileFlagsMask;
      D.16487 = D.16485 & D.16486;
      D.16488 = (int) D.16487;
      D.16490 = D.16488 & 2;
      process_set_field_bool (filever, "isprerelease", D.16490);
      ffi.6 = ffi;
      D.16485 = ffi.6->dwFileFlags;
      ffi.6 = ffi;
      D.16486 = ffi.6->dwFileFlagsMask;
      D.16487 = D.16485 & D.16486;
      D.16488 = (int) D.16487;
      D.16491 = D.16488 & 4;
      process_set_field_bool (filever, "ispatched", D.16491);
      ffi.6 = ffi;
      D.16485 = ffi.6->dwFileFlags;
      ffi.6 = ffi;
      D.16486 = ffi.6->dwFileFlagsMask;
      D.16487 = D.16485 & D.16486;
      D.16488 = (int) D.16487;
      D.16492 = D.16488 & 8;
      process_set_field_bool (filever, "isprivatebuild", D.16492);
      ffi.6 = ffi;
      D.16485 = ffi.6->dwFileFlags;
      ffi.6 = ffi;
      D.16486 = ffi.6->dwFileFlagsMask;
      D.16487 = D.16485 & D.16486;
      D.16488 = (int) D.16487;
      D.16493 = D.16488 & 32;
      process_set_field_bool (filever, "isspecialbuild", D.16493);
      <D.16459>:
      monoeg_g_free (query);
      query = monoeg_g_utf8_to_utf16 ("\\VarFileInfo\\Translation", -1, 0B, 0B, 0B);
      if (query == 0B) goto <D.16494>; else goto <D.16495>;
      <D.16494>:
      monoeg_g_free (data);
      return;
      <D.16495>:
      D.16496 = VerQueryValue (data, query, &trans_data, &trans_size);
      if (D.16496 != 0) goto <D.16497>; else goto <D.16498>;
      <D.16497>:
      trans_size.7 = trans_size;
      if (trans_size.7 > 3) goto <D.16500>; else goto <D.16501>;
      <D.16500>:
      trans_data.8 = trans_data;
      D.16503 = *trans_data.8;
      D.16504 = (int) D.16503;
      trans_data.8 = trans_data;
      D.16505 = trans_data.8 + 1;
      D.16506 = *D.16505;
      D.16507 = (int) D.16506;
      D.16508 = D.16507 << 8;
      D.16509 = D.16504 | D.16508;
      trans_data.8 = trans_data;
      D.16510 = trans_data.8 + 2;
      D.16511 = *D.16510;
      D.16512 = (int) D.16511;
      D.16513 = D.16512 << 16;
      D.16514 = D.16509 | D.16513;
      trans_data.8 = trans_data;
      D.16515 = trans_data.8 + 3;
      D.16516 = *D.16515;
      D.16517 = (int) D.16516;
      D.16518 = D.16517 << 24;
      D.16519 = D.16514 | D.16518;
      lang = (guint32) D.16519;
      D.16520 = lang & 65535;
      lang_count = VerLanguageName (D.16520, &lang_buf, 128);
      if (lang_count != 0) goto <D.16521>; else goto <D.16522>;
      <D.16521>:
      process_set_field_string (filever, "language", &lang_buf, lang_count);
      <D.16522>:
      trans_data.8 = trans_data;
      D.16503 = *trans_data.8;
      D.16504 = (int) D.16503;
      trans_data.8 = trans_data;
      D.16505 = trans_data.8 + 1;
      D.16506 = *D.16505;
      D.16507 = (int) D.16506;
      process_module_stringtable (filever, data, D.16504, D.16507);
      <D.16501>:
      goto <D.16523>;
      <D.16498>:
      process_set_field_string (filever, "comments", "", 0);
      process_set_field_string (filever, "companyname", "", 0);
      process_set_field_string (filever, "filedescription", "", 0);
      process_set_field_string (filever, "fileversion", "", 0);
      process_set_field_string (filever, "internalname", "", 0);
      process_set_field_string (filever, "legalcopyright", "", 0);
      process_set_field_string (filever, "legaltrademarks", "", 0);
      process_set_field_string (filever, "originalfilename", "", 0);
      process_set_field_string (filever, "privatebuild", "", 0);
      process_set_field_string (filever, "productname", "", 0);
      process_set_field_string (filever, "productversion", "", 0);
      process_set_field_string (filever, "specialbuild", "", 0);
      lang_count = VerLanguageName (1033, &lang_buf, 128);
      if (lang_count != 0) goto <D.16524>; else goto <D.16525>;
      <D.16524>:
      process_set_field_string (filever, "language", &lang_buf, lang_count);
      <D.16525>:
      <D.16523>:
      monoeg_g_free (query);
      <D.16454>:
      monoeg_g_free (data);
      <D.16451>:
    }
  finally
    {
      verinfohandle = {CLOBBER};
      ffi = {CLOBBER};
      trans_data = {CLOBBER};
      ffi_size = {CLOBBER};
      trans_size = {CLOBBER};
      lang_buf = {CLOBBER};
    }
}


process_set_field_bool (struct MonoObject * obj, const gchar * fieldname, gboolean val)
{
  struct MonoVTable * D.16529;
  struct MonoClass * D.16530;
  int D.16531;
  sizetype D.16532;
  guint8 * D.16533;
  unsigned char D.16534;
  struct MonoClassField * field;

  D.16529 = obj->vtable;
  D.16530 = D.16529->klass;
  field = mono_class_get_field_from_name (D.16530, fieldname);
  D.16531 = field->offset;
  D.16532 = (sizetype) D.16531;
  D.16533 = obj + D.16532;
  D.16534 = (unsigned char) val;
  *D.16533 = D.16534;
}


process_module_stringtable (struct MonoObject * filever, void * data, guchar lang_hi, guchar lang_lo)
{
  int D.16535;
  int D.16536;

  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "comments", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\Comments");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "companyname", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\CompanyName");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "filedescription", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\FileDescription");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "fileversion", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\FileVersion");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "internalname", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\InternalName");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "legalcopyright", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\LegalCopyright");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "legaltrademarks", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\LegalTrademarks");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "originalfilename", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\OriginalFilename");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "privatebuild", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\PrivateBuild");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "productname", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\ProductName");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "productversion", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\ProductVersion");
  D.16535 = (int) lang_hi;
  D.16536 = (int) lang_lo;
  process_module_string_read (filever, data, "specialbuild", D.16535, D.16536, "\\StringFileInfo\\%02X%02X%02X%02X\\SpecialBuild");
}


process_module_string_read (struct MonoObject * filever, void * data, const gchar * fieldname, guchar lang_hi, guchar lang_lo, const gchar * key)
{
  int D.16537;
  int D.16538;
  int D.16541;
  unsigned int chars.9;
  gunichar2 * buffer.10;
  unsigned int D.16546;
  gchar * lang_key_utf8;
  gunichar2 * lang_key;
  gunichar2 * buffer;
  UINT chars;

  try
    {
      D.16537 = (int) lang_lo;
      D.16538 = (int) lang_hi;
      lang_key_utf8 = monoeg_g_strdup_printf (key, D.16537, D.16538, 4, 176);
      lang_key = monoeg_g_utf8_to_utf16 (lang_key_utf8, -1, 0B, 0B, 0B);
      D.16541 = VerQueryValue (data, lang_key, &buffer, &chars);
      if (D.16541 != 0) goto <D.16542>; else goto <D.16539>;
      <D.16542>:
      chars.9 = chars;
      if (chars.9 != 0) goto <D.16544>; else goto <D.16539>;
      <D.16544>:
      buffer.10 = buffer;
      chars.9 = chars;
      D.16546 = chars.9 + 4294967295;
      process_set_field_string (filever, fieldname, buffer.10, D.16546);
      goto <D.16540>;
      <D.16539>:
      process_set_field_string (filever, fieldname, "", 0);
      <D.16540>:
      monoeg_g_free (lang_key);
      monoeg_g_free (lang_key_utf8);
    }
  finally
    {
      buffer = {CLOBBER};
      chars = {CLOBBER};
    }
}


process_set_field_intptr (struct MonoObject * obj, const gchar * fieldname, void * val)
{
  struct MonoVTable * D.16547;
  struct MonoClass * D.16548;
  int D.16549;
  sizetype D.16550;
  void * * D.16551;
  struct MonoClassField * field;

  D.16547 = obj->vtable;
  D.16548 = D.16547->klass;
  field = mono_class_get_field_from_name (D.16548, fieldname);
  D.16549 = field->offset;
  D.16550 = (sizetype) D.16549;
  D.16551 = obj + D.16550;
  *D.16551 = val;
}


process_set_field_int (struct MonoObject * obj, const gchar * fieldname, guint32 val)
{
  struct MonoVTable * D.16552;
  struct MonoClass * D.16553;
  int D.16554;
  sizetype D.16555;
  guint32 * D.16556;
  struct MonoClassField * field;

  D.16552 = obj->vtable;
  D.16553 = D.16552->klass;
  field = mono_class_get_field_from_name (D.16553, fieldname);
  D.16554 = field->offset;
  D.16555 = (sizetype) D.16554;
  D.16556 = obj + D.16555;
  *D.16556 = val;
}


unicode_chars (const gunichar2 * str)
{
  unsigned int D.16557;
  const gunichar2 * D.16558;
  short unsigned int D.16559;
  guint32 D.16562;
  guint32 len;

  len = 0;
  <D.16136>:
  D.16557 = len * 2;
  D.16558 = str + D.16557;
  D.16559 = *D.16558;
  if (D.16559 == 0) goto <D.16560>; else goto <D.16561>;
  <D.16560>:
  D.16562 = len;
  return D.16562;
  <D.16561>:
  len = len + 1;
  goto <D.16136>;
}


process_set_field_string (struct MonoObject * obj, const gchar * fieldname, const gunichar2 * val, guint32 len)
{
  struct MonoVTable * D.16564;
  struct MonoDomain * D.16565;
  int len.11;
  struct MonoClass * D.16567;
  int D.16568;
  sizetype D.16569;
  void * D.16570;
  struct MonoClassField * field;
  struct MonoString * string;

  D.16564 = obj->vtable;
  D.16565 = D.16564->domain;
  len.11 = (int) len;
  string = mono_string_new_utf16 (D.16565, val, len.11);
  D.16564 = obj->vtable;
  D.16567 = D.16564->klass;
  field = mono_class_get_field_from_name (D.16567, fieldname);
  D.16568 = field->offset;
  D.16569 = (sizetype) D.16568;
  D.16570 = obj + D.16569;
  mono_gc_wbarrier_generic_store (D.16570, string);
}


process_set_field_object (struct MonoObject * obj, const gchar * fieldname, struct MonoObject * data)
{
  struct MonoVTable * D.16571;
  struct MonoClass * D.16572;
  int D.16573;
  sizetype D.16574;
  void * D.16575;
  struct MonoClassField * field;

  D.16571 = obj->vtable;
  D.16572 = D.16571->klass;
  field = mono_class_get_field_from_name (D.16572, fieldname);
  D.16573 = field->offset;
  D.16574 = (sizetype) D.16573;
  D.16575 = obj + D.16574;
  mono_gc_wbarrier_generic_store (D.16575, data);
}


ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (struct MonoObject * this, struct MonoString * filename)
{
  struct MonoImage * system_assembly.12;
  struct MonoVTable * D.16579;
  struct MonoClass * D.16580;
  struct MonoImage * system_assembly.13;
  mono_unichar2 * D.16582;
  mono_unichar2 * D.16583;
  int D.16584;
  unsigned int D.16585;

  system_assembly.12 = system_assembly;
  if (system_assembly.12 == 0B) goto <D.16577>; else goto <D.16578>;
  <D.16577>:
  D.16579 = this->vtable;
  D.16580 = D.16579->klass;
  system_assembly.13 = D.16580->image;
  system_assembly = system_assembly.13;
  <D.16578>:
  D.16582 = mono_string_chars (filename);
  process_get_fileversion (this, D.16582);
  D.16583 = mono_string_chars (filename);
  D.16584 = mono_string_length (filename);
  D.16585 = (unsigned int) D.16584;
  process_set_field_string (this, "filename", D.16583, D.16585);
}


ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (struct MonoProcessStartInfo * proc_start_info, struct MonoProcInfo * process_info)
{
  unsigned int D.16586;
  WapiShellExecuteShowFlags iftmp.14;
  <unnamed type> D.16588;
  WapiShellExecuteShowFlags iftmp.15;
  struct MonoString * D.16596;
  mono_unichar2 * D.16599;
  struct MonoString * D.16600;
  mono_unichar2 * D.16603;
  struct MonoString * D.16604;
  int D.16607;
  mono_unichar2 * D.16610;
  struct MonoString * D.16611;
  int D.16614;
  mono_unichar2 * D.16617;
  unsigned char D.16618;
  void * D.16621;
  <unnamed type> D.16623;
  unsigned int D.16624;
  unsigned int D.16627;
  unsigned int D.16628;
  void * D.16630;
  unsigned int D.16631;
  MonoBoolean D.16632;
  struct SHELLEXECUTEINFO shellex;
  gboolean ret;

  try
    {
      shellex = {};
      shellex.cbSize = 60;
      shellex.fMask = 65856;
      D.16586 = proc_start_info->window_style;
      shellex.nShow = D.16586;
      D.16588 = shellex.nShow;
      if (D.16588 != 0) goto <D.16589>; else goto <D.16590>;
      <D.16589>:
      D.16588 = shellex.nShow;
      if (D.16588 != 1) goto <D.16592>; else goto <D.16593>;
      <D.16592>:
      iftmp.15 = shellex.nShow;
      goto <D.16594>;
      <D.16593>:
      iftmp.15 = 0;
      <D.16594>:
      iftmp.14 = iftmp.15;
      goto <D.16595>;
      <D.16590>:
      iftmp.14 = 1;
      <D.16595>:
      shellex.nShow = iftmp.14;
      D.16596 = proc_start_info->filename;
      if (D.16596 != 0B) goto <D.16597>; else goto <D.16598>;
      <D.16597>:
      D.16596 = proc_start_info->filename;
      D.16599 = mono_string_chars (D.16596);
      shellex.lpFile = D.16599;
      <D.16598>:
      D.16600 = proc_start_info->arguments;
      if (D.16600 != 0B) goto <D.16601>; else goto <D.16602>;
      <D.16601>:
      D.16600 = proc_start_info->arguments;
      D.16603 = mono_string_chars (D.16600);
      shellex.lpParameters = D.16603;
      <D.16602>:
      D.16604 = proc_start_info->verb;
      if (D.16604 != 0B) goto <D.16605>; else goto <D.16606>;
      <D.16605>:
      D.16604 = proc_start_info->verb;
      D.16607 = mono_string_length (D.16604);
      if (D.16607 != 0) goto <D.16608>; else goto <D.16609>;
      <D.16608>:
      D.16604 = proc_start_info->verb;
      D.16610 = mono_string_chars (D.16604);
      shellex.lpVerb = D.16610;
      <D.16609>:
      <D.16606>:
      D.16611 = proc_start_info->working_directory;
      if (D.16611 != 0B) goto <D.16612>; else goto <D.16613>;
      <D.16612>:
      D.16611 = proc_start_info->working_directory;
      D.16614 = mono_string_length (D.16611);
      if (D.16614 != 0) goto <D.16615>; else goto <D.16616>;
      <D.16615>:
      D.16611 = proc_start_info->working_directory;
      D.16617 = mono_string_chars (D.16611);
      shellex.lpDirectory = D.16617;
      <D.16616>:
      <D.16613>:
      D.16618 = proc_start_info->error_dialog;
      if (D.16618 != 0) goto <D.16619>; else goto <D.16620>;
      <D.16619>:
      D.16621 = proc_start_info->error_dialog_parent_handle;
      shellex.hwnd = D.16621;
      goto <D.16622>;
      <D.16620>:
      D.16623 = shellex.fMask;
      D.16624 = D.16623 | 1024;
      shellex.fMask = D.16624;
      <D.16622>:
      ret = ShellExecuteEx (&shellex);
      if (ret == 0) goto <D.16625>; else goto <D.16626>;
      <D.16625>:
      D.16627 = GetLastError ();
      D.16628 = -D.16627;
      process_info->pid = D.16628;
      goto <D.16629>;
      <D.16626>:
      D.16630 = shellex.hProcess;
      process_info->process_handle = D.16630;
      process_info->thread_handle = 0B;
      D.16630 = shellex.hProcess;
      D.16631 = GetProcessId (D.16630);
      process_info->pid = D.16631;
      process_info->tid = 0;
      <D.16629>:
      D.16632 = (MonoBoolean) ret;
      return D.16632;
    }
  finally
    {
      shellex = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_CreateProcess_internal (struct MonoProcessStartInfo * proc_start_info, void * stdin_handle, void * stdout_handle, void * stderr_handle, struct MonoProcInfo * process_info)
{
  unsigned char D.16635;
  struct MonoString * D.16638;
  gchar * spath.16;
  MonoBoolean D.16642;
  struct MonoArray * D.16643;
  struct MonoArray * D.16646;
  unsigned int i.17;
  char * D.16648;
  int D.16651;
  unsigned int D.16652;
  unsigned int D.16653;
  unsigned int len.18;
  unsigned int D.16655;
  char * D.16656;
  int D.16657;
  unsigned int D.16658;
  unsigned int D.16659;
  unsigned int D.16660;
  unsigned int D.16661;
  unsigned int D.16662;
  int D.16663;
  unsigned int D.16664;
  unsigned int D.16665;
  char * D.16666;
  char * D.16669;
  mono_unichar2 * D.16670;
  int D.16671;
  unsigned int D.16672;
  unsigned int D.16673;
  int D.16674;
  unsigned int D.16675;
  unsigned int D.16676;
  mono_unichar2 * D.16677;
  int D.16678;
  unsigned int D.16679;
  unsigned int D.16680;
  int D.16681;
  unsigned int D.16682;
  unsigned int D.16683;
  unsigned int D.16684;
  struct MonoString * D.16688;
  int D.16690;
  struct MonoString * D.16691;
  unsigned char D.16694;
  _Bool D.16695;
  mono_unichar2 * D.16696;
  const gunichar2 * iftmp.19;
  struct MonoString * D.16698;
  void * D.16702;
  const gunichar2 * iftmp.20;
  const gunichar2 * iftmp.21;
  void * D.16716;
  void * D.16717;
  void * D.16718;
  unsigned int D.16721;
  unsigned int D.16722;
  unsigned int D.16724;
  unsigned int D.16725;
  gboolean ret;
  gunichar2 * dir;
  struct STARTUPINFO startinfo;
  struct PROCESS_INFORMATION procinfo;
  gunichar2 * shell_path;
  gchar * env_vars;
  gboolean free_shell_path;
  gchar * spath;
  struct MonoString * cmd;
  guint32 creation_flags;
  guint32 logon_flags;

  try
    {
      startinfo = {};
      shell_path = 0B;
      env_vars = 0B;
      free_shell_path = 1;
      spath = 0B;
      cmd = proc_start_info->arguments;
      startinfo.cb = 68;
      startinfo.dwFlags = 256;
      startinfo.hStdInput = stdin_handle;
      startinfo.hStdOutput = stdout_handle;
      startinfo.hStdError = stderr_handle;
      creation_flags = 1024;
      D.16635 = proc_start_info->create_no_window;
      if (D.16635 != 0) goto <D.16636>; else goto <D.16637>;
      <D.16636>:
      creation_flags = creation_flags | 134217728;
      <D.16637>:
      D.16638 = proc_start_info->filename;
      shell_path = mono_string_chars (D.16638);
      complete_path (shell_path, &spath);
      spath.16 = spath;
      if (spath.16 == 0B) goto <D.16640>; else goto <D.16641>;
      <D.16640>:
      process_info->pid = 4294967294;
      D.16642 = 0;
      return D.16642;
      <D.16641>:
      spath.16 = spath;
      shell_path = monoeg_g_utf8_to_utf16 (spath.16, -1, 0B, 0B, 0B);
      spath.16 = spath;
      monoeg_g_free (spath.16);
      D.16643 = process_info->env_keys;
      if (D.16643 != 0B) goto <D.16644>; else goto <D.16645>;
      <D.16644>:
      {
        gint i;
        gint len;
        struct MonoString * ms;
        struct MonoString * key;
        struct MonoString * value;
        gunichar2 * str;
        gunichar2 * ptr;
        gunichar2 * equals16;

        len = 0;
        i = 0;
        goto <D.16287>;
        <D.16286>:
        D.16646 = process_info->env_values;
        i.17 = (unsigned int) i;
        D.16648 = mono_array_addr_with_size (D.16646, 4, i.17);
        ms = MEM[(struct MonoString * *)D.16648];
        if (ms == 0B) goto <D.16649>; else goto <D.16650>;
        <D.16649>:
        // predicted unlikely by continue predictor.
        goto <D.16285>;
        <D.16650>:
        D.16651 = mono_string_length (ms);
        D.16652 = (unsigned int) D.16651;
        D.16653 = D.16652 * 2;
        len.18 = (unsigned int) len;
        D.16655 = D.16653 + len.18;
        len = (gint) D.16655;
        D.16643 = process_info->env_keys;
        i.17 = (unsigned int) i;
        D.16656 = mono_array_addr_with_size (D.16643, 4, i.17);
        ms = MEM[(struct MonoString * *)D.16656];
        D.16657 = mono_string_length (ms);
        D.16658 = (unsigned int) D.16657;
        D.16659 = D.16658 * 2;
        len.18 = (unsigned int) len;
        D.16660 = D.16659 + len.18;
        len = (gint) D.16660;
        len.18 = (unsigned int) len;
        D.16661 = len.18 + 4;
        len = (gint) D.16661;
        <D.16285>:
        i = i + 1;
        <D.16287>:
        i.17 = (unsigned int) i;
        D.16643 = process_info->env_keys;
        D.16662 = mono_array_length (D.16643);
        if (i.17 < D.16662) goto <D.16286>; else goto <D.16288>;
        <D.16288>:
        equals16 = monoeg_g_utf8_to_utf16 ("=", 1, 0B, 0B, 0B);
        D.16663 = len + 1;
        D.16664 = (unsigned int) D.16663;
        D.16665 = D.16664 * 2;
        str = monoeg_malloc0 (D.16665);
        ptr = str;
        i = 0;
        goto <D.16291>;
        <D.16290>:
        D.16646 = process_info->env_values;
        i.17 = (unsigned int) i;
        D.16666 = mono_array_addr_with_size (D.16646, 4, i.17);
        value = MEM[(struct MonoString * *)D.16666];
        if (value == 0B) goto <D.16667>; else goto <D.16668>;
        <D.16667>:
        // predicted unlikely by continue predictor.
        goto <D.16289>;
        <D.16668>:
        D.16643 = process_info->env_keys;
        i.17 = (unsigned int) i;
        D.16669 = mono_array_addr_with_size (D.16643, 4, i.17);
        key = MEM[(struct MonoString * *)D.16669];
        D.16670 = mono_string_chars (key);
        D.16671 = mono_string_length (key);
        D.16672 = (unsigned int) D.16671;
        D.16673 = D.16672 * 2;
        memcpy (ptr, D.16670, D.16673);
        D.16674 = mono_string_length (key);
        D.16675 = (unsigned int) D.16674;
        D.16676 = D.16675 * 2;
        ptr = ptr + D.16676;
        memcpy (ptr, equals16, 2);
        ptr = ptr + 2;
        D.16677 = mono_string_chars (value);
        D.16678 = mono_string_length (value);
        D.16679 = (unsigned int) D.16678;
        D.16680 = D.16679 * 2;
        memcpy (ptr, D.16677, D.16680);
        D.16681 = mono_string_length (value);
        D.16682 = (unsigned int) D.16681;
        D.16683 = D.16682 * 2;
        ptr = ptr + D.16683;
        ptr = ptr + 2;
        <D.16289>:
        i = i + 1;
        <D.16291>:
        i.17 = (unsigned int) i;
        D.16643 = process_info->env_keys;
        D.16684 = mono_array_length (D.16643);
        if (i.17 < D.16684) goto <D.16290>; else goto <D.16292>;
        <D.16292>:
        monoeg_g_free (equals16);
        env_vars = str;
      }
      <D.16645>:
      D.16688 = proc_start_info->working_directory;
      if (D.16688 == 0B) goto <D.16685>; else goto <D.16689>;
      <D.16689>:
      D.16688 = proc_start_info->working_directory;
      D.16690 = mono_string_length (D.16688);
      if (D.16690 == 0) goto <D.16685>; else goto <D.16686>;
      <D.16685>:
      dir = 0B;
      goto <D.16687>;
      <D.16686>:
      D.16688 = proc_start_info->working_directory;
      dir = mono_string_chars (D.16688);
      <D.16687>:
      D.16691 = process_info->username;
      if (D.16691 != 0B) goto <D.16692>; else goto <D.16693>;
      <D.16692>:
      D.16694 = process_info->load_user_profile;
      D.16695 = D.16694 != 0;
      logon_flags = (guint32) D.16695;
      D.16691 = process_info->username;
      D.16696 = mono_string_chars (D.16691);
      D.16698 = process_info->domain;
      if (D.16698 != 0B) goto <D.16699>; else goto <D.16700>;
      <D.16699>:
      D.16698 = process_info->domain;
      iftmp.19 = mono_string_chars (D.16698);
      goto <D.16701>;
      <D.16700>:
      iftmp.19 = 0B;
      <D.16701>:
      D.16702 = process_info->password;
      if (cmd != 0B) goto <D.16704>; else goto <D.16705>;
      <D.16704>:
      iftmp.20 = mono_string_chars (cmd);
      goto <D.16706>;
      <D.16705>:
      iftmp.20 = 0B;
      <D.16706>:
      ret = CreateProcessWithLogonW (D.16696, iftmp.19, D.16702, logon_flags, shell_path, iftmp.20, creation_flags, env_vars, dir, &startinfo, &procinfo);
      goto <D.16707>;
      <D.16693>:
      if (cmd != 0B) goto <D.16709>; else goto <D.16710>;
      <D.16709>:
      iftmp.21 = mono_string_chars (cmd);
      goto <D.16711>;
      <D.16710>:
      iftmp.21 = 0B;
      <D.16711>:
      ret = CreateProcess (shell_path, iftmp.21, 0B, 0B, 1, creation_flags, env_vars, dir, &startinfo, &procinfo);
      <D.16707>:
      monoeg_g_free (env_vars);
      if (free_shell_path != 0) goto <D.16712>; else goto <D.16713>;
      <D.16712>:
      monoeg_g_free (shell_path);
      <D.16713>:
      if (ret != 0) goto <D.16714>; else goto <D.16715>;
      <D.16714>:
      D.16716 = procinfo.hProcess;
      process_info->process_handle = D.16716;
      process_info->thread_handle = 0B;
      D.16717 = procinfo.hThread;
      D.16718 = D.16717 + 4294967295;
      if (D.16718 <= 4294967293B) goto <D.16719>; else goto <D.16720>;
      <D.16719>:
      D.16717 = procinfo.hThread;
      CloseHandle (D.16717);
      <D.16720>:
      D.16721 = procinfo.dwProcessId;
      process_info->pid = D.16721;
      D.16722 = procinfo.dwThreadId;
      process_info->tid = D.16722;
      goto <D.16723>;
      <D.16715>:
      D.16724 = GetLastError ();
      D.16725 = -D.16724;
      process_info->pid = D.16725;
      <D.16723>:
      D.16642 = (MonoBoolean) ret;
      return D.16642;
    }
  finally
    {
      startinfo = {CLOBBER};
      procinfo = {CLOBBER};
      spath = {CLOBBER};
    }
}


complete_path (const gunichar2 * appname, gchar * * completed)
{
  int D.16728;
  gchar * D.16731;
  gboolean D.16732;
  int D.16733;
  int D.16736;
  gchar * D.16739;
  gchar * D.16742;
  gchar * utf8app;
  gchar * utf8appmemory;
  gchar * found;

  utf8app = monoeg_g_utf16_to_utf8 (appname, -1, 0B, 0B, 0B);
  utf8appmemory = utf8app;
  D.16728 = monoeg_g_path_is_absolute (utf8app);
  if (D.16728 != 0) goto <D.16729>; else goto <D.16730>;
  <D.16729>:
  D.16731 = quote_path (utf8app);
  *completed = D.16731;
  monoeg_g_free (utf8appmemory);
  D.16732 = 1;
  return D.16732;
  <D.16730>:
  D.16733 = monoeg_g_file_test (utf8app, 8);
  if (D.16733 != 0) goto <D.16734>; else goto <D.16735>;
  <D.16734>:
  D.16736 = monoeg_g_file_test (utf8app, 4);
  if (D.16736 == 0) goto <D.16737>; else goto <D.16738>;
  <D.16737>:
  D.16739 = quote_path (utf8app);
  *completed = D.16739;
  monoeg_g_free (utf8appmemory);
  D.16732 = 1;
  return D.16732;
  <D.16738>:
  <D.16735>:
  found = monoeg_g_find_program_in_path (utf8app);
  if (found == 0B) goto <D.16740>; else goto <D.16741>;
  <D.16740>:
  *completed = 0B;
  monoeg_g_free (utf8appmemory);
  D.16732 = 0;
  return D.16732;
  <D.16741>:
  D.16742 = quote_path (found);
  *completed = D.16742;
  monoeg_g_free (found);
  monoeg_g_free (utf8appmemory);
  D.16732 = 1;
  return D.16732;
}


quote_path (const gchar * path)
{
  gchar * D.16744;
  gchar * res;

  res = monoeg_g_shell_quote (path);
  D.16744 = res;
  return D.16744;
}


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

  D.16747 = __builtin_object_size (__dest, 0);
  D.16746 = __builtin___memcpy_chk (__dest, __src, __len, D.16747);
  return D.16746;
}


ves_icall_System_Diagnostics_Process_WaitForExit_internal (struct MonoObject * this, void * process, gint32 ms)
{
  unsigned int ms.22;
  MonoBoolean D.16755;
  guint32 ret;

  if (ms < 0) goto <D.16749>; else goto <D.16750>;
  <D.16749>:
  ret = WaitForSingleObjectEx (process, 4294967295, 1);
  goto <D.16751>;
  <D.16750>:
  ms.22 = (unsigned int) ms;
  ret = WaitForSingleObjectEx (process, ms.22, 1);
  <D.16751>:
  if (ret == 0) goto <D.16753>; else goto <D.16754>;
  <D.16753>:
  D.16755 = 1;
  return D.16755;
  <D.16754>:
  D.16755 = 0;
  return D.16755;
}


ves_icall_System_Diagnostics_Process_WaitForInputIdle_internal (struct MonoObject * this, void * process, gint32 ms)
{
  unsigned int ms.23;
  MonoBoolean D.16761;
  _Bool D.16762;
  guint32 ret;

  if (ms < 0) goto <D.16757>; else goto <D.16758>;
  <D.16757>:
  ret = WaitForInputIdle (process, 4294967295);
  goto <D.16759>;
  <D.16758>:
  ms.23 = (unsigned int) ms;
  ret = WaitForInputIdle (process, ms.23);
  <D.16759>:
  D.16762 = ret == 0;
  D.16761 = (MonoBoolean) D.16762;
  return D.16761;
}


ves_icall_System_Diagnostics_Process_ExitTime_internal (void * process)
{
  unsigned int D.16766;
  long long unsigned int D.16767;
  long long unsigned int D.16768;
  unsigned int D.16769;
  long long unsigned int D.16770;
  long long unsigned int D.16771;
  gint64 D.16772;
  gboolean ret;
  gint64 ticks;
  struct FILETIME create_time;
  struct FILETIME exit_time;
  struct FILETIME kernel_time;
  struct FILETIME user_time;

  try
    {
      ret = GetProcessTimes (process, &create_time, &exit_time, &kernel_time, &user_time);
      if (ret == 1) goto <D.16764>; else goto <D.16765>;
      <D.16764>:
      D.16766 = exit_time.dwHighDateTime;
      D.16767 = (long long unsigned int) D.16766;
      D.16768 = D.16767 << 32;
      D.16769 = exit_time.dwLowDateTime;
      D.16770 = (long long unsigned int) D.16769;
      D.16771 = D.16768 + D.16770;
      ticks = (gint64) D.16771;
      D.16772 = ticks;
      return D.16772;
      <D.16765>:
      D.16772 = 0;
      return D.16772;
    }
  finally
    {
      create_time = {CLOBBER};
      exit_time = {CLOBBER};
      kernel_time = {CLOBBER};
      user_time = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_StartTime_internal (void * process)
{
  unsigned int D.16777;
  long long unsigned int D.16778;
  long long unsigned int D.16779;
  unsigned int D.16780;
  long long unsigned int D.16781;
  long long unsigned int D.16782;
  gint64 D.16783;
  gboolean ret;
  gint64 ticks;
  struct FILETIME create_time;
  struct FILETIME exit_time;
  struct FILETIME kernel_time;
  struct FILETIME user_time;

  try
    {
      ret = GetProcessTimes (process, &create_time, &exit_time, &kernel_time, &user_time);
      if (ret == 1) goto <D.16775>; else goto <D.16776>;
      <D.16775>:
      D.16777 = create_time.dwHighDateTime;
      D.16778 = (long long unsigned int) D.16777;
      D.16779 = D.16778 << 32;
      D.16780 = create_time.dwLowDateTime;
      D.16781 = (long long unsigned int) D.16780;
      D.16782 = D.16779 + D.16781;
      ticks = (gint64) D.16782;
      D.16783 = ticks;
      return D.16783;
      <D.16776>:
      D.16783 = 0;
      return D.16783;
    }
  finally
    {
      create_time = {CLOBBER};
      exit_time = {CLOBBER};
      kernel_time = {CLOBBER};
      user_time = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_ExitCode_internal (void * process)
{
  gint32 D.16786;
  unsigned int code.24;
  DWORD code;

  try
    {
      GetExitCodeProcess (process, &code);
      code.24 = code;
      D.16786 = (gint32) code.24;
      return D.16786;
    }
  finally
    {
      code = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_ProcessName_internal (void * process)
{
  struct MonoString * D.16792;
  void * mod.25;
  struct MonoDomain * D.16796;
  int len.26;
  struct MonoString * string;
  gboolean ok;
  void * mod;
  gunichar2 name[260];
  DWORD needed;
  guint32 len;

  try
    {
      ok = EnumProcessModules (process, &mod, 4, &needed);
      if (ok == 0) goto <D.16790>; else goto <D.16791>;
      <D.16790>:
      D.16792 = 0B;
      return D.16792;
      <D.16791>:
      mod.25 = mod;
      len = GetModuleBaseName (process, mod.25, &name, 260);
      if (len == 0) goto <D.16794>; else goto <D.16795>;
      <D.16794>:
      D.16792 = 0B;
      return D.16792;
      <D.16795>:
      D.16796 = mono_domain_get ();
      len.26 = (int) len;
      string = mono_string_new_utf16 (D.16796, &name, len.26);
      D.16792 = string;
      return D.16792;
    }
  finally
    {
      mod = {CLOBBER};
      name = {CLOBBER};
      needed = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_GetProcesses_internal ()
{
  unsigned int D.16800;
  unsigned int D.16801;
  unsigned int needed.27;
  unsigned int D.16806;
  struct MonoDomain * D.16807;
  struct MonoClass * D.16808;
  char * D.16809;
  struct MonoArray * D.16810;
  struct MonoArray * procs;
  gboolean ret;
  DWORD needed;
  guint32 count;
  guint32 * pids;

  try
    {
      count = 512;
      <D.16346>:
      D.16800 = count * 4;
      pids = monoeg_malloc0 (D.16800);
      D.16801 = count * 4;
      ret = EnumProcesses (pids, D.16801, &needed);
      if (ret == 0) goto <D.16802>; else goto <D.16803>;
      <D.16802>:
      {
        struct MonoException * exc;

        monoeg_g_free (pids);
        pids = 0B;
        exc = mono_get_exception_not_supported ("This system does not support EnumProcesses");
        mono_raise_exception (exc);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "process.c", 920);
      }
      <D.16803>:
      D.16801 = count * 4;
      needed.27 = needed;
      if (D.16801 > needed.27) goto <D.16345>; else goto <D.16805>;
      <D.16805>:
      monoeg_g_free (pids);
      pids = 0B;
      D.16806 = count * 3;
      count = D.16806 / 2;
      goto <D.16346>;
      <D.16345>:
      needed.27 = needed;
      count = needed.27 / 4;
      D.16807 = mono_domain_get ();
      D.16808 = mono_get_int32_class ();
      procs = mono_array_new (D.16807, D.16808, count);
      D.16809 = mono_array_addr_with_size (procs, 4, 0);
      needed.27 = needed;
      memcpy (D.16809, pids, needed.27);
      monoeg_g_free (pids);
      pids = 0B;
      D.16810 = procs;
      return D.16810;
    }
  finally
    {
      needed = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_GetWorkingSet_internal (void * process, guint32 * min, guint32 * max)
{
  unsigned int ws_min.28;
  unsigned int ws_max.29;
  MonoBoolean D.16815;
  gboolean ret;
  SIZE_T ws_min;
  SIZE_T ws_max;

  try
    {
      ret = GetProcessWorkingSetSize (process, &ws_min, &ws_max);
      ws_min.28 = ws_min;
      *min = ws_min.28;
      ws_max.29 = ws_max;
      *max = ws_max.29;
      D.16815 = (MonoBoolean) ret;
      return D.16815;
    }
  finally
    {
      ws_min = {CLOBBER};
      ws_max = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_SetWorkingSet_internal (void * process, guint32 min, guint32 max, MonoBoolean use_min)
{
  MonoBoolean D.16820;
  unsigned int ws_min.30;
  unsigned int ws_max.31;
  gboolean ret;
  SIZE_T ws_min;
  SIZE_T ws_max;

  try
    {
      ret = GetProcessWorkingSetSize (process, &ws_min, &ws_max);
      if (ret == 0) goto <D.16818>; else goto <D.16819>;
      <D.16818>:
      D.16820 = 0;
      return D.16820;
      <D.16819>:
      if (use_min == 1) goto <D.16821>; else goto <D.16822>;
      <D.16821>:
      ws_min = min;
      goto <D.16823>;
      <D.16822>:
      ws_max = max;
      <D.16823>:
      ws_min.30 = ws_min;
      ws_max.31 = ws_max;
      ret = SetProcessWorkingSetSize (process, ws_min.30, ws_max.31);
      D.16820 = (MonoBoolean) ret;
      return D.16820;
    }
  finally
    {
      ws_min = {CLOBBER};
      ws_max = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_Kill_internal (void * process, gint32 sig)
{
  MonoBoolean D.16828;
  int D.16829;
  int D.16830;

  D.16829 = -sig;
  D.16830 = TerminateProcess (process, D.16829);
  D.16828 = (MonoBoolean) D.16830;
  return D.16828;
}


ves_icall_System_Diagnostics_Process_Times (void * process, gint32 type)
{
  int D.16832;
  gint64 D.16837;
  struct FILETIME * user_time.32;
  struct FILETIME * kernel_time.33;
  long long int D.16842;
  long long int D.16843;
  struct FILETIME create_time;
  struct FILETIME exit_time;
  struct FILETIME kernel_time;
  struct FILETIME user_time;

  try
    {
      D.16832 = GetProcessTimes (process, &create_time, &exit_time, &kernel_time, &user_time);
      if (D.16832 != 0) goto <D.16833>; else goto <D.16834>;
      <D.16833>:
      if (type == 0) goto <D.16835>; else goto <D.16836>;
      <D.16835>:
      user_time.32 = &user_time;
      D.16837 = MEM[(gint64 *)user_time.32];
      return D.16837;
      <D.16836>:
      if (type == 1) goto <D.16839>; else goto <D.16840>;
      <D.16839>:
      kernel_time.33 = &kernel_time;
      D.16837 = MEM[(gint64 *)kernel_time.33];
      return D.16837;
      <D.16840>:
      kernel_time.33 = &kernel_time;
      D.16842 = MEM[(gint64 *)kernel_time.33];
      user_time.32 = &user_time;
      D.16843 = MEM[(gint64 *)user_time.32];
      D.16837 = D.16842 + D.16843;
      return D.16837;
      <D.16834>:
      D.16837 = 0;
      return D.16837;
    }
  finally
    {
      create_time = {CLOBBER};
      exit_time = {CLOBBER};
      kernel_time = {CLOBBER};
      user_time = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_GetPriorityClass (void * process, gint32 * error)
{
  unsigned int D.16846;
  gint32 iftmp.34;
  unsigned int D.16850;
  gint32 D.16852;
  gint32 ret;

  D.16846 = GetPriorityClass (process);
  ret = (gint32) D.16846;
  if (ret == 0) goto <D.16848>; else goto <D.16849>;
  <D.16848>:
  D.16850 = GetLastError ();
  iftmp.34 = (gint32) D.16850;
  goto <D.16851>;
  <D.16849>:
  iftmp.34 = 0;
  <D.16851>:
  *error = iftmp.34;
  D.16852 = ret;
  return D.16852;
}


ves_icall_System_Diagnostics_Process_SetPriorityClass (void * process, gint32 priority_class, gint32 * error)
{
  unsigned int priority_class.35;
  gint32 iftmp.36;
  unsigned int D.16858;
  MonoBoolean D.16860;
  gboolean ret;

  priority_class.35 = (unsigned int) priority_class;
  ret = SetPriorityClass (process, priority_class.35);
  if (ret == 0) goto <D.16856>; else goto <D.16857>;
  <D.16856>:
  D.16858 = GetLastError ();
  iftmp.36 = (gint32) D.16858;
  goto <D.16859>;
  <D.16857>:
  iftmp.36 = 0;
  <D.16859>:
  *error = iftmp.36;
  D.16860 = (MonoBoolean) ret;
  return D.16860;
}


ves_icall_System_Diagnostics_Process_ProcessHandle_duplicate (void * process)
{
  void * D.16862;
  void * D.16863;
  void * D.16864;
  void * ret;

  try
    {
      D.16862 = GetCurrentProcess ();
      D.16863 = GetCurrentProcess ();
      DuplicateHandle (D.16862, process, D.16863, &ret, 2032639, 1, 0);
      D.16864 = ret;
      return D.16864;
    }
  finally
    {
      ret = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_Process_ProcessHandle_close (void * process)
{
  CloseHandle (process);
}


ves_icall_System_Diagnostics_Process_GetProcessData (int pid, gint32 data_type, gint32 * error)
{
  void * pid.37;
  <unnamed type> data_type.38;
  long long int D.16869;
  <unnamed type> perror.39;
  int perror.40;
  gint64 D.16874;
  MonoProcessError perror;
  guint64 res;

  try
    {
      pid.37 = (void *) pid;
      data_type.38 = (<unnamed type>) data_type;
      D.16869 = mono_process_get_data_with_error (pid.37, data_type.38, &perror);
      res = (guint64) D.16869;
      if (error != 0B) goto <D.16870>; else goto <D.16871>;
      <D.16870>:
      perror.39 = perror;
      perror.40 = (int) perror.39;
      *error = perror.40;
      <D.16871>:
      D.16874 = (gint64) res;
      return D.16874;
    }
  finally
    {
      perror = {CLOBBER};
    }
}