__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid)
{
  void * D.16946;
  void * handle;

  handle = OpenProcess (2035711, 1, pid);
  if (handle == 0B) goto <D.16944>; else goto <D.16945>;
  <D.16944>:
  D.16946 = 0B;
  return D.16946;
  <D.16945>:
  D.16946 = handle;
  return D.16946;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_GetPid_internal ()
{
  guint32 D.16948;

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


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_Process_free_internal (struct MonoObject * this, void * process)
{
  CloseProcess (process);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_GetModules_internal (struct MonoObject * this, void * process)
{
  struct MonoImage * system_assembly.0;
  struct MonoVTable * D.16953;
  struct MonoClass * D.16954;
  struct MonoImage * D.16955;
  int D.16956;
  unsigned int needed.1;
  struct MonoDomain * D.16960;
  struct MonoClass * D.16961;
  long unsigned int D.16962;
  void * D.16963;
  unsigned int D.16964;
  unsigned int D.16967;
  unsigned int num_added.2;
  long unsigned int D.16971;
  struct MonoDomain * D.16975;
  struct MonoClass * D.16976;
  long unsigned int D.16977;
  long unsigned int D.16978;
  char * D.16979;
  struct MonoObject * D.16980;
  struct MonoArray * D.16981;
  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.16951>; else goto <D.16952>;
      <D.16951>:
      D.16953 = this->vtable;
      D.16954 = D.16953->klass;
      D.16955 = D.16954->image;
      system_assembly = D.16955;
      <D.16952>:
      D.16956 = EnumProcessModules (process, &mods, 8192, &needed);
      if (D.16956 != 0) goto <D.16957>; else goto <D.16958>;
      <D.16957>:
      needed.1 = needed;
      count = needed.1 / 8;
      D.16960 = mono_domain_get ();
      D.16961 = mono_get_object_class ();
      D.16962 = (long unsigned int) count;
      temp_arr = mono_array_new (D.16960, D.16961, D.16962);
      i = 0;
      goto <D.16774>;
      <D.16773>:
      D.16963 = mods[i];
      D.16964 = GetModuleBaseName (process, D.16963, &modname, 260);
      if (D.16964 != 0) goto <D.16965>; else goto <D.16966>;
      <D.16965>:
      D.16963 = mods[i];
      D.16967 = GetModuleFileNameEx (process, D.16963, &filename, 260);
      if (D.16967 != 0) goto <D.16968>; else goto <D.16969>;
      <D.16968>:
      {
        struct MonoObject * module;

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

          num_added.2 = num_added;
          num_added = num_added.2 + 1;
          D.16971 = (long unsigned int) num_added.2;
          __p = mono_array_addr_with_size (temp_arr, 8, D.16971);
          mono_gc_wbarrier_set_arrayref (temp_arr, __p, module);
        }
      }
      <D.16969>:
      <D.16966>:
      i = i + 1;
      <D.16774>:
      if (i < count) goto <D.16773>; else goto <D.16775>;
      <D.16775>:
      <D.16958>:
      if (count == num_added) goto <D.16972>; else goto <D.16973>;
      <D.16972>:
      arr = temp_arr;
      goto <D.16974>;
      <D.16973>:
      D.16975 = mono_domain_get ();
      D.16976 = mono_get_object_class ();
      D.16977 = (long unsigned int) num_added;
      arr = mono_array_new (D.16975, D.16976, D.16977);
      i = 0;
      goto <D.16778>;
      <D.16777>:
      {
        void * * __p;

        D.16978 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 8, D.16978);
        D.16978 = (long unsigned int) i;
        D.16979 = mono_array_addr_with_size (temp_arr, 8, D.16978);
        D.16980 = MEM[(struct MonoObject * *)D.16979];
        mono_gc_wbarrier_set_arrayref (arr, __p, D.16980);
      }
      i = i + 1;
      <D.16778>:
      if (i < num_added) goto <D.16777>; else goto <D.16779>;
      <D.16779>:
      <D.16974>:
      D.16981 = arr;
      return D.16981;
    }
  finally
    {
      mods = {CLOBBER};
      filename = {CLOBBER};
      modname = {CLOBBER};
      needed = {CLOBBER};
    }
}


process_add_module (void * process, void * mod, gunichar2 * filename, gunichar2 * modulename)
{
  struct MonoImage * system_assembly.3;
  unsigned int D.16985;
  void * D.16988;
  void * D.16989;
  unsigned int D.16990;
  unsigned int D.16991;
  unsigned int D.16992;
  struct MonoObject * D.16993;
  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.3 = system_assembly;
      proc_class = mono_class_from_name (system_assembly.3, "System.Diagnostics", "ProcessModule");
      item = mono_object_new (domain, proc_class);
      system_assembly.3 = system_assembly;
      filever_class = mono_class_from_name (system_assembly.3, "System.Diagnostics", "FileVersionInfo");
      filever = mono_object_new (domain, filever_class);
      process_get_fileversion (filever, filename);
      D.16985 = unicode_chars (filename);
      process_set_field_string (filever, "filename", filename, D.16985);
      ok = GetModuleInformation (process, mod, &modinfo, 24);
      if (ok != 0) goto <D.16986>; else goto <D.16987>;
      <D.16986>:
      D.16988 = modinfo.lpBaseOfDll;
      process_set_field_intptr (item, "baseaddr", D.16988);
      D.16989 = modinfo.EntryPoint;
      process_set_field_intptr (item, "entryaddr", D.16989);
      D.16990 = modinfo.SizeOfImage;
      process_set_field_int (item, "memory_size", D.16990);
      <D.16987>:
      D.16991 = unicode_chars (filename);
      process_set_field_string (item, "filename", filename, D.16991);
      D.16992 = unicode_chars (modulename);
      process_set_field_string (item, "modulename", modulename, D.16992);
      process_set_field_object (item, "version_info", filever);
      D.16993 = item;
      return D.16993;
    }
  finally
    {
      modinfo = {CLOBBER};
    }
}


process_get_fileversion (struct MonoObject * filever, gunichar2 * filename)
{
  long unsigned int D.16998;
  unsigned int verinfohandle.4;
  int D.17004;
  struct VS_FIXEDFILEINFO * ffi.5;
  unsigned int D.17008;
  unsigned int D.17009;
  short unsigned int D.17010;
  unsigned int D.17011;
  short unsigned int D.17012;
  unsigned int D.17013;
  unsigned int D.17014;
  unsigned int D.17015;
  short unsigned int D.17016;
  unsigned int D.17017;
  short unsigned int D.17018;
  unsigned int D.17019;
  unsigned int D.17020;
  unsigned int D.17021;
  short unsigned int D.17022;
  unsigned int D.17023;
  short unsigned int D.17024;
  unsigned int D.17025;
  unsigned int D.17026;
  unsigned int D.17027;
  short unsigned int D.17028;
  unsigned int D.17029;
  short unsigned int D.17030;
  unsigned int D.17031;
  unsigned int D.17032;
  unsigned int D.17033;
  unsigned int D.17034;
  int D.17035;
  int D.17036;
  int D.17037;
  int D.17038;
  int D.17039;
  int D.17040;
  int D.17043;
  unsigned int trans_size.6;
  guchar * trans_data.7;
  unsigned char D.17050;
  int D.17051;
  guchar * D.17052;
  unsigned char D.17053;
  int D.17054;
  int D.17055;
  int D.17056;
  guchar * D.17057;
  unsigned char D.17058;
  int D.17059;
  int D.17060;
  int D.17061;
  guchar * D.17062;
  unsigned char D.17063;
  int D.17064;
  int D.17065;
  int D.17066;
  unsigned int D.17067;
  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.16996>; else goto <D.16997>;
      <D.16996>:
      D.16998 = (long unsigned int) datalen;
      data = monoeg_malloc0 (D.16998);
      verinfohandle.4 = verinfohandle;
      ok = GetFileVersionInfo (filename, verinfohandle.4, datalen, data);
      if (ok != 0) goto <D.17000>; else goto <D.17001>;
      <D.17000>:
      query = monoeg_g_utf8_to_utf16 ("\\", -1, 0B, 0B, 0B);
      if (query == 0B) goto <D.17002>; else goto <D.17003>;
      <D.17002>:
      monoeg_g_free (data);
      return;
      <D.17003>:
      D.17004 = VerQueryValue (data, query, &ffi, &ffi_size);
      if (D.17004 != 0) goto <D.17005>; else goto <D.17006>;
      <D.17005>:
      ffi.5 = ffi;
      D.17008 = ffi.5->dwFileVersionMS;
      D.17009 = D.17008 >> 16;
      D.17010 = (short unsigned int) D.17009;
      D.17011 = (unsigned int) D.17010;
      process_set_field_int (filever, "filemajorpart", D.17011);
      ffi.5 = ffi;
      D.17008 = ffi.5->dwFileVersionMS;
      D.17012 = (short unsigned int) D.17008;
      D.17013 = (unsigned int) D.17012;
      process_set_field_int (filever, "fileminorpart", D.17013);
      ffi.5 = ffi;
      D.17014 = ffi.5->dwFileVersionLS;
      D.17015 = D.17014 >> 16;
      D.17016 = (short unsigned int) D.17015;
      D.17017 = (unsigned int) D.17016;
      process_set_field_int (filever, "filebuildpart", D.17017);
      ffi.5 = ffi;
      D.17014 = ffi.5->dwFileVersionLS;
      D.17018 = (short unsigned int) D.17014;
      D.17019 = (unsigned int) D.17018;
      process_set_field_int (filever, "fileprivatepart", D.17019);
      ffi.5 = ffi;
      D.17020 = ffi.5->dwProductVersionMS;
      D.17021 = D.17020 >> 16;
      D.17022 = (short unsigned int) D.17021;
      D.17023 = (unsigned int) D.17022;
      process_set_field_int (filever, "productmajorpart", D.17023);
      ffi.5 = ffi;
      D.17020 = ffi.5->dwProductVersionMS;
      D.17024 = (short unsigned int) D.17020;
      D.17025 = (unsigned int) D.17024;
      process_set_field_int (filever, "productminorpart", D.17025);
      ffi.5 = ffi;
      D.17026 = ffi.5->dwProductVersionLS;
      D.17027 = D.17026 >> 16;
      D.17028 = (short unsigned int) D.17027;
      D.17029 = (unsigned int) D.17028;
      process_set_field_int (filever, "productbuildpart", D.17029);
      ffi.5 = ffi;
      D.17026 = ffi.5->dwProductVersionLS;
      D.17030 = (short unsigned int) D.17026;
      D.17031 = (unsigned int) D.17030;
      process_set_field_int (filever, "productprivatepart", D.17031);
      ffi.5 = ffi;
      D.17032 = ffi.5->dwFileFlags;
      ffi.5 = ffi;
      D.17033 = ffi.5->dwFileFlagsMask;
      D.17034 = D.17032 & D.17033;
      D.17035 = (int) D.17034;
      D.17036 = D.17035 & 1;
      process_set_field_bool (filever, "isdebug", D.17036);
      ffi.5 = ffi;
      D.17032 = ffi.5->dwFileFlags;
      ffi.5 = ffi;
      D.17033 = ffi.5->dwFileFlagsMask;
      D.17034 = D.17032 & D.17033;
      D.17035 = (int) D.17034;
      D.17037 = D.17035 & 2;
      process_set_field_bool (filever, "isprerelease", D.17037);
      ffi.5 = ffi;
      D.17032 = ffi.5->dwFileFlags;
      ffi.5 = ffi;
      D.17033 = ffi.5->dwFileFlagsMask;
      D.17034 = D.17032 & D.17033;
      D.17035 = (int) D.17034;
      D.17038 = D.17035 & 4;
      process_set_field_bool (filever, "ispatched", D.17038);
      ffi.5 = ffi;
      D.17032 = ffi.5->dwFileFlags;
      ffi.5 = ffi;
      D.17033 = ffi.5->dwFileFlagsMask;
      D.17034 = D.17032 & D.17033;
      D.17035 = (int) D.17034;
      D.17039 = D.17035 & 8;
      process_set_field_bool (filever, "isprivatebuild", D.17039);
      ffi.5 = ffi;
      D.17032 = ffi.5->dwFileFlags;
      ffi.5 = ffi;
      D.17033 = ffi.5->dwFileFlagsMask;
      D.17034 = D.17032 & D.17033;
      D.17035 = (int) D.17034;
      D.17040 = D.17035 & 32;
      process_set_field_bool (filever, "isspecialbuild", D.17040);
      <D.17006>:
      monoeg_g_free (query);
      query = monoeg_g_utf8_to_utf16 ("\\VarFileInfo\\Translation", -1, 0B, 0B, 0B);
      if (query == 0B) goto <D.17041>; else goto <D.17042>;
      <D.17041>:
      monoeg_g_free (data);
      return;
      <D.17042>:
      D.17043 = VerQueryValue (data, query, &trans_data, &trans_size);
      if (D.17043 != 0) goto <D.17044>; else goto <D.17045>;
      <D.17044>:
      trans_size.6 = trans_size;
      if (trans_size.6 > 3) goto <D.17047>; else goto <D.17048>;
      <D.17047>:
      trans_data.7 = trans_data;
      D.17050 = *trans_data.7;
      D.17051 = (int) D.17050;
      trans_data.7 = trans_data;
      D.17052 = trans_data.7 + 1;
      D.17053 = *D.17052;
      D.17054 = (int) D.17053;
      D.17055 = D.17054 << 8;
      D.17056 = D.17051 | D.17055;
      trans_data.7 = trans_data;
      D.17057 = trans_data.7 + 2;
      D.17058 = *D.17057;
      D.17059 = (int) D.17058;
      D.17060 = D.17059 << 16;
      D.17061 = D.17056 | D.17060;
      trans_data.7 = trans_data;
      D.17062 = trans_data.7 + 3;
      D.17063 = *D.17062;
      D.17064 = (int) D.17063;
      D.17065 = D.17064 << 24;
      D.17066 = D.17061 | D.17065;
      lang = (guint32) D.17066;
      D.17067 = lang & 65535;
      lang_count = VerLanguageName (D.17067, &lang_buf, 128);
      if (lang_count != 0) goto <D.17068>; else goto <D.17069>;
      <D.17068>:
      process_set_field_string (filever, "language", &lang_buf, lang_count);
      <D.17069>:
      trans_data.7 = trans_data;
      D.17050 = *trans_data.7;
      trans_data.7 = trans_data;
      D.17052 = trans_data.7 + 1;
      D.17053 = *D.17052;
      process_module_stringtable (filever, data, D.17050, D.17053);
      <D.17048>:
      goto <D.17070>;
      <D.17045>:
      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.17071>; else goto <D.17072>;
      <D.17071>:
      process_set_field_string (filever, "language", &lang_buf, lang_count);
      <D.17072>:
      <D.17070>:
      monoeg_g_free (query);
      <D.17001>:
      monoeg_g_free (data);
      <D.16997>:
    }
  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.17076;
  struct MonoClass * D.17077;
  int D.17078;
  sizetype D.17079;
  guint8 * D.17080;
  unsigned char D.17081;
  struct MonoClassField * field;

  D.17076 = obj->vtable;
  D.17077 = D.17076->klass;
  field = mono_class_get_field_from_name (D.17077, fieldname);
  D.17078 = field->offset;
  D.17079 = (sizetype) D.17078;
  D.17080 = obj + D.17079;
  D.17081 = (unsigned char) val;
  *D.17080 = D.17081;
}


process_module_stringtable (struct MonoObject * filever, void * data, guchar lang_hi, guchar lang_lo)
{
  process_module_string_read (filever, data, "comments", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\Comments");
  process_module_string_read (filever, data, "companyname", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\CompanyName");
  process_module_string_read (filever, data, "filedescription", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\FileDescription");
  process_module_string_read (filever, data, "fileversion", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\FileVersion");
  process_module_string_read (filever, data, "internalname", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\InternalName");
  process_module_string_read (filever, data, "legalcopyright", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\LegalCopyright");
  process_module_string_read (filever, data, "legaltrademarks", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\LegalTrademarks");
  process_module_string_read (filever, data, "originalfilename", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\OriginalFilename");
  process_module_string_read (filever, data, "privatebuild", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\PrivateBuild");
  process_module_string_read (filever, data, "productname", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\ProductName");
  process_module_string_read (filever, data, "productversion", lang_hi, lang_lo, "\\StringFileInfo\\%02X%02X%02X%02X\\ProductVersion");
  process_module_string_read (filever, data, "specialbuild", lang_hi, lang_lo, "\\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.17082;
  int D.17083;
  int D.17086;
  unsigned int chars.8;
  gunichar2 * buffer.9;
  unsigned int D.17091;
  gchar * lang_key_utf8;
  gunichar2 * lang_key;
  gunichar2 * buffer;
  UINT chars;

  try
    {
      D.17082 = (int) lang_lo;
      D.17083 = (int) lang_hi;
      lang_key_utf8 = monoeg_g_strdup_printf (key, D.17082, D.17083, 4, 176);
      lang_key = monoeg_g_utf8_to_utf16 (lang_key_utf8, -1, 0B, 0B, 0B);
      D.17086 = VerQueryValue (data, lang_key, &buffer, &chars);
      if (D.17086 != 0) goto <D.17087>; else goto <D.17084>;
      <D.17087>:
      chars.8 = chars;
      if (chars.8 != 0) goto <D.17089>; else goto <D.17084>;
      <D.17089>:
      buffer.9 = buffer;
      chars.8 = chars;
      D.17091 = chars.8 + 4294967295;
      process_set_field_string (filever, fieldname, buffer.9, D.17091);
      goto <D.17085>;
      <D.17084>:
      process_set_field_string (filever, fieldname, "", 0);
      <D.17085>:
      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.17092;
  struct MonoClass * D.17093;
  int D.17094;
  sizetype D.17095;
  void * * D.17096;
  struct MonoClassField * field;

  D.17092 = obj->vtable;
  D.17093 = D.17092->klass;
  field = mono_class_get_field_from_name (D.17093, fieldname);
  D.17094 = field->offset;
  D.17095 = (sizetype) D.17094;
  D.17096 = obj + D.17095;
  *D.17096 = val;
}


process_set_field_int (struct MonoObject * obj, const gchar * fieldname, guint32 val)
{
  struct MonoVTable * D.17097;
  struct MonoClass * D.17098;
  int D.17099;
  sizetype D.17100;
  guint32 * D.17101;
  struct MonoClassField * field;

  D.17097 = obj->vtable;
  D.17098 = D.17097->klass;
  field = mono_class_get_field_from_name (D.17098, fieldname);
  D.17099 = field->offset;
  D.17100 = (sizetype) D.17099;
  D.17101 = obj + D.17100;
  *D.17101 = val;
}


unicode_chars (const gunichar2 * str)
{
  long unsigned int D.17102;
  long unsigned int D.17103;
  const gunichar2 * D.17104;
  short unsigned int D.17105;
  guint32 D.17108;
  guint32 len;

  len = 0;
  <D.16678>:
  D.17102 = (long unsigned int) len;
  D.17103 = D.17102 * 2;
  D.17104 = str + D.17103;
  D.17105 = *D.17104;
  if (D.17105 == 0) goto <D.17106>; else goto <D.17107>;
  <D.17106>:
  D.17108 = len;
  return D.17108;
  <D.17107>:
  len = len + 1;
  goto <D.16678>;
}


process_set_field_string (struct MonoObject * obj, const gchar * fieldname, const gunichar2 * val, guint32 len)
{
  struct MonoVTable * D.17110;
  struct MonoDomain * D.17111;
  int len.10;
  struct MonoClass * D.17113;
  int D.17114;
  sizetype D.17115;
  void * D.17116;
  struct MonoClassField * field;
  struct MonoString * string;

  D.17110 = obj->vtable;
  D.17111 = D.17110->domain;
  len.10 = (int) len;
  string = mono_string_new_utf16 (D.17111, val, len.10);
  D.17110 = obj->vtable;
  D.17113 = D.17110->klass;
  field = mono_class_get_field_from_name (D.17113, fieldname);
  D.17114 = field->offset;
  D.17115 = (sizetype) D.17114;
  D.17116 = obj + D.17115;
  mono_gc_wbarrier_generic_store (D.17116, string);
}


process_set_field_object (struct MonoObject * obj, const gchar * fieldname, struct MonoObject * data)
{
  struct MonoVTable * D.17117;
  struct MonoClass * D.17118;
  int D.17119;
  sizetype D.17120;
  void * D.17121;
  struct MonoClassField * field;

  D.17117 = obj->vtable;
  D.17118 = D.17117->klass;
  field = mono_class_get_field_from_name (D.17118, fieldname);
  D.17119 = field->offset;
  D.17120 = (sizetype) D.17119;
  D.17121 = obj + D.17120;
  mono_gc_wbarrier_generic_store (D.17121, data);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (struct MonoObject * this, struct MonoString * filename)
{
  struct MonoImage * system_assembly.11;
  struct MonoVTable * D.17125;
  struct MonoClass * D.17126;
  struct MonoImage * D.17127;
  mono_unichar2 * D.17128;
  mono_unichar2 * D.17129;
  int D.17130;
  unsigned int D.17131;

  system_assembly.11 = system_assembly;
  if (system_assembly.11 == 0B) goto <D.17123>; else goto <D.17124>;
  <D.17123>:
  D.17125 = this->vtable;
  D.17126 = D.17125->klass;
  D.17127 = D.17126->image;
  system_assembly = D.17127;
  <D.17124>:
  D.17128 = mono_string_chars (filename);
  process_get_fileversion (this, D.17128);
  D.17129 = mono_string_chars (filename);
  D.17130 = mono_string_length (filename);
  D.17131 = (unsigned int) D.17130;
  process_set_field_string (this, "filename", D.17129, D.17131);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (struct MonoProcessStartInfo * proc_start_info, struct MonoProcInfo * process_info)
{
  unsigned int D.17132;
  WapiShellExecuteShowFlags iftmp.12;
  <unnamed type> D.17134;
  WapiShellExecuteShowFlags iftmp.13;
  struct MonoString * D.17142;
  mono_unichar2 * D.17145;
  struct MonoString * D.17146;
  mono_unichar2 * D.17149;
  struct MonoString * D.17150;
  int D.17153;
  mono_unichar2 * D.17156;
  struct MonoString * D.17157;
  int D.17160;
  mono_unichar2 * D.17163;
  unsigned char D.17164;
  void * D.17167;
  <unnamed type> D.17169;
  unsigned int D.17170;
  unsigned int D.17173;
  unsigned int D.17174;
  void * D.17176;
  unsigned int D.17177;
  MonoBoolean D.17178;
  struct SHELLEXECUTEINFO shellex;
  gboolean ret;

  try
    {
      shellex = {};
      shellex.cbSize = 112;
      shellex.fMask = 65856;
      D.17132 = proc_start_info->window_style;
      shellex.nShow = D.17132;
      D.17134 = shellex.nShow;
      if (D.17134 != 0) goto <D.17135>; else goto <D.17136>;
      <D.17135>:
      D.17134 = shellex.nShow;
      if (D.17134 != 1) goto <D.17138>; else goto <D.17139>;
      <D.17138>:
      iftmp.13 = shellex.nShow;
      goto <D.17140>;
      <D.17139>:
      iftmp.13 = 0;
      <D.17140>:
      iftmp.12 = iftmp.13;
      goto <D.17141>;
      <D.17136>:
      iftmp.12 = 1;
      <D.17141>:
      shellex.nShow = iftmp.12;
      D.17142 = proc_start_info->filename;
      if (D.17142 != 0B) goto <D.17143>; else goto <D.17144>;
      <D.17143>:
      D.17142 = proc_start_info->filename;
      D.17145 = mono_string_chars (D.17142);
      shellex.lpFile = D.17145;
      <D.17144>:
      D.17146 = proc_start_info->arguments;
      if (D.17146 != 0B) goto <D.17147>; else goto <D.17148>;
      <D.17147>:
      D.17146 = proc_start_info->arguments;
      D.17149 = mono_string_chars (D.17146);
      shellex.lpParameters = D.17149;
      <D.17148>:
      D.17150 = proc_start_info->verb;
      if (D.17150 != 0B) goto <D.17151>; else goto <D.17152>;
      <D.17151>:
      D.17150 = proc_start_info->verb;
      D.17153 = mono_string_length (D.17150);
      if (D.17153 != 0) goto <D.17154>; else goto <D.17155>;
      <D.17154>:
      D.17150 = proc_start_info->verb;
      D.17156 = mono_string_chars (D.17150);
      shellex.lpVerb = D.17156;
      <D.17155>:
      <D.17152>:
      D.17157 = proc_start_info->working_directory;
      if (D.17157 != 0B) goto <D.17158>; else goto <D.17159>;
      <D.17158>:
      D.17157 = proc_start_info->working_directory;
      D.17160 = mono_string_length (D.17157);
      if (D.17160 != 0) goto <D.17161>; else goto <D.17162>;
      <D.17161>:
      D.17157 = proc_start_info->working_directory;
      D.17163 = mono_string_chars (D.17157);
      shellex.lpDirectory = D.17163;
      <D.17162>:
      <D.17159>:
      D.17164 = proc_start_info->error_dialog;
      if (D.17164 != 0) goto <D.17165>; else goto <D.17166>;
      <D.17165>:
      D.17167 = proc_start_info->error_dialog_parent_handle;
      shellex.hwnd = D.17167;
      goto <D.17168>;
      <D.17166>:
      D.17169 = shellex.fMask;
      D.17170 = D.17169 | 1024;
      shellex.fMask = D.17170;
      <D.17168>:
      ret = ShellExecuteEx (&shellex);
      if (ret == 0) goto <D.17171>; else goto <D.17172>;
      <D.17171>:
      D.17173 = GetLastError ();
      D.17174 = -D.17173;
      process_info->pid = D.17174;
      goto <D.17175>;
      <D.17172>:
      D.17176 = shellex.hProcess;
      process_info->process_handle = D.17176;
      process_info->thread_handle = 0B;
      D.17176 = shellex.hProcess;
      D.17177 = GetProcessId (D.17176);
      process_info->pid = D.17177;
      process_info->tid = 0;
      <D.17175>:
      D.17178 = (MonoBoolean) ret;
      return D.17178;
    }
  finally
    {
      shellex = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.17181;
  struct MonoString * D.17184;
  gchar * spath.14;
  MonoBoolean D.17188;
  struct MonoArray * D.17189;
  struct MonoArray * D.17192;
  long unsigned int D.17193;
  char * D.17194;
  int D.17197;
  long unsigned int D.17198;
  long unsigned int D.17199;
  unsigned int D.17200;
  unsigned int len.15;
  unsigned int D.17202;
  char * D.17203;
  int D.17204;
  long unsigned int D.17205;
  long unsigned int D.17206;
  unsigned int D.17207;
  unsigned int D.17208;
  unsigned int D.17209;
  long unsigned int D.17210;
  int D.17211;
  long unsigned int D.17212;
  long unsigned int D.17213;
  char * D.17214;
  char * D.17217;
  mono_unichar2 * D.17218;
  int D.17219;
  long unsigned int D.17220;
  long unsigned int D.17221;
  int D.17222;
  long unsigned int D.17223;
  long unsigned int D.17224;
  mono_unichar2 * D.17225;
  int D.17226;
  long unsigned int D.17227;
  long unsigned int D.17228;
  int D.17229;
  long unsigned int D.17230;
  long unsigned int D.17231;
  long unsigned int D.17232;
  struct MonoString * D.17236;
  int D.17238;
  struct MonoString * D.17239;
  unsigned char D.17242;
  _Bool D.17243;
  mono_unichar2 * D.17244;
  const gunichar2 * iftmp.16;
  struct MonoString * D.17246;
  void * D.17250;
  const gunichar2 * iftmp.17;
  const gunichar2 * iftmp.18;
  void * D.17264;
  void * D.17265;
  void * D.17266;
  unsigned int D.17269;
  unsigned int D.17270;
  unsigned int D.17272;
  unsigned int D.17273;
  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 = 104;
      startinfo.dwFlags = 256;
      startinfo.hStdInput = stdin_handle;
      startinfo.hStdOutput = stdout_handle;
      startinfo.hStdError = stderr_handle;
      creation_flags = 1024;
      D.17181 = proc_start_info->create_no_window;
      if (D.17181 != 0) goto <D.17182>; else goto <D.17183>;
      <D.17182>:
      creation_flags = creation_flags | 134217728;
      <D.17183>:
      D.17184 = proc_start_info->filename;
      shell_path = mono_string_chars (D.17184);
      complete_path (shell_path, &spath);
      spath.14 = spath;
      if (spath.14 == 0B) goto <D.17186>; else goto <D.17187>;
      <D.17186>:
      process_info->pid = 4294967294;
      D.17188 = 0;
      return D.17188;
      <D.17187>:
      spath.14 = spath;
      shell_path = monoeg_g_utf8_to_utf16 (spath.14, -1, 0B, 0B, 0B);
      spath.14 = spath;
      monoeg_g_free (spath.14);
      D.17189 = process_info->env_keys;
      if (D.17189 != 0B) goto <D.17190>; else goto <D.17191>;
      <D.17190>:
      {
        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.16829>;
        <D.16828>:
        D.17192 = process_info->env_values;
        D.17193 = (long unsigned int) i;
        D.17194 = mono_array_addr_with_size (D.17192, 8, D.17193);
        ms = MEM[(struct MonoString * *)D.17194];
        if (ms == 0B) goto <D.17195>; else goto <D.17196>;
        <D.17195>:
        // predicted unlikely by continue predictor.
        goto <D.16827>;
        <D.17196>:
        D.17197 = mono_string_length (ms);
        D.17198 = (long unsigned int) D.17197;
        D.17199 = D.17198 * 2;
        D.17200 = (unsigned int) D.17199;
        len.15 = (unsigned int) len;
        D.17202 = D.17200 + len.15;
        len = (gint) D.17202;
        D.17189 = process_info->env_keys;
        D.17193 = (long unsigned int) i;
        D.17203 = mono_array_addr_with_size (D.17189, 8, D.17193);
        ms = MEM[(struct MonoString * *)D.17203];
        D.17204 = mono_string_length (ms);
        D.17205 = (long unsigned int) D.17204;
        D.17206 = D.17205 * 2;
        D.17207 = (unsigned int) D.17206;
        len.15 = (unsigned int) len;
        D.17208 = D.17207 + len.15;
        len = (gint) D.17208;
        len.15 = (unsigned int) len;
        D.17209 = len.15 + 4;
        len = (gint) D.17209;
        <D.16827>:
        i = i + 1;
        <D.16829>:
        D.17193 = (long unsigned int) i;
        D.17189 = process_info->env_keys;
        D.17210 = mono_array_length (D.17189);
        if (D.17193 < D.17210) goto <D.16828>; else goto <D.16830>;
        <D.16830>:
        equals16 = monoeg_g_utf8_to_utf16 ("=", 1, 0B, 0B, 0B);
        D.17211 = len + 1;
        D.17212 = (long unsigned int) D.17211;
        D.17213 = D.17212 * 2;
        str = monoeg_malloc0 (D.17213);
        ptr = str;
        i = 0;
        goto <D.16833>;
        <D.16832>:
        D.17192 = process_info->env_values;
        D.17193 = (long unsigned int) i;
        D.17214 = mono_array_addr_with_size (D.17192, 8, D.17193);
        value = MEM[(struct MonoString * *)D.17214];
        if (value == 0B) goto <D.17215>; else goto <D.17216>;
        <D.17215>:
        // predicted unlikely by continue predictor.
        goto <D.16831>;
        <D.17216>:
        D.17189 = process_info->env_keys;
        D.17193 = (long unsigned int) i;
        D.17217 = mono_array_addr_with_size (D.17189, 8, D.17193);
        key = MEM[(struct MonoString * *)D.17217];
        D.17218 = mono_string_chars (key);
        D.17219 = mono_string_length (key);
        D.17220 = (long unsigned int) D.17219;
        D.17221 = D.17220 * 2;
        memcpy (ptr, D.17218, D.17221);
        D.17222 = mono_string_length (key);
        D.17223 = (long unsigned int) D.17222;
        D.17224 = D.17223 * 2;
        ptr = ptr + D.17224;
        memcpy (ptr, equals16, 2);
        ptr = ptr + 2;
        D.17225 = mono_string_chars (value);
        D.17226 = mono_string_length (value);
        D.17227 = (long unsigned int) D.17226;
        D.17228 = D.17227 * 2;
        memcpy (ptr, D.17225, D.17228);
        D.17229 = mono_string_length (value);
        D.17230 = (long unsigned int) D.17229;
        D.17231 = D.17230 * 2;
        ptr = ptr + D.17231;
        ptr = ptr + 2;
        <D.16831>:
        i = i + 1;
        <D.16833>:
        D.17193 = (long unsigned int) i;
        D.17189 = process_info->env_keys;
        D.17232 = mono_array_length (D.17189);
        if (D.17193 < D.17232) goto <D.16832>; else goto <D.16834>;
        <D.16834>:
        monoeg_g_free (equals16);
        env_vars = str;
      }
      <D.17191>:
      D.17236 = proc_start_info->working_directory;
      if (D.17236 == 0B) goto <D.17233>; else goto <D.17237>;
      <D.17237>:
      D.17236 = proc_start_info->working_directory;
      D.17238 = mono_string_length (D.17236);
      if (D.17238 == 0) goto <D.17233>; else goto <D.17234>;
      <D.17233>:
      dir = 0B;
      goto <D.17235>;
      <D.17234>:
      D.17236 = proc_start_info->working_directory;
      dir = mono_string_chars (D.17236);
      <D.17235>:
      D.17239 = process_info->username;
      if (D.17239 != 0B) goto <D.17240>; else goto <D.17241>;
      <D.17240>:
      D.17242 = process_info->load_user_profile;
      D.17243 = D.17242 != 0;
      logon_flags = (guint32) D.17243;
      D.17239 = process_info->username;
      D.17244 = mono_string_chars (D.17239);
      D.17246 = process_info->domain;
      if (D.17246 != 0B) goto <D.17247>; else goto <D.17248>;
      <D.17247>:
      D.17246 = process_info->domain;
      iftmp.16 = mono_string_chars (D.17246);
      goto <D.17249>;
      <D.17248>:
      iftmp.16 = 0B;
      <D.17249>:
      D.17250 = process_info->password;
      if (cmd != 0B) goto <D.17252>; else goto <D.17253>;
      <D.17252>:
      iftmp.17 = mono_string_chars (cmd);
      goto <D.17254>;
      <D.17253>:
      iftmp.17 = 0B;
      <D.17254>:
      ret = CreateProcessWithLogonW (D.17244, iftmp.16, D.17250, logon_flags, shell_path, iftmp.17, creation_flags, env_vars, dir, &startinfo, &procinfo);
      goto <D.17255>;
      <D.17241>:
      if (cmd != 0B) goto <D.17257>; else goto <D.17258>;
      <D.17257>:
      iftmp.18 = mono_string_chars (cmd);
      goto <D.17259>;
      <D.17258>:
      iftmp.18 = 0B;
      <D.17259>:
      ret = CreateProcess (shell_path, iftmp.18, 0B, 0B, 1, creation_flags, env_vars, dir, &startinfo, &procinfo);
      <D.17255>:
      monoeg_g_free (env_vars);
      if (free_shell_path != 0) goto <D.17260>; else goto <D.17261>;
      <D.17260>:
      monoeg_g_free (shell_path);
      <D.17261>:
      if (ret != 0) goto <D.17262>; else goto <D.17263>;
      <D.17262>:
      D.17264 = procinfo.hProcess;
      process_info->process_handle = D.17264;
      process_info->thread_handle = 0B;
      D.17265 = procinfo.hThread;
      D.17266 = D.17265 + 18446744073709551615;
      if (D.17266 <= -3B) goto <D.17267>; else goto <D.17268>;
      <D.17267>:
      D.17265 = procinfo.hThread;
      CloseHandle (D.17265);
      <D.17268>:
      D.17269 = procinfo.dwProcessId;
      process_info->pid = D.17269;
      D.17270 = procinfo.dwThreadId;
      process_info->tid = D.17270;
      goto <D.17271>;
      <D.17263>:
      D.17272 = GetLastError ();
      D.17273 = -D.17272;
      process_info->pid = D.17273;
      <D.17271>:
      D.17188 = (MonoBoolean) ret;
      return D.17188;
    }
  finally
    {
      startinfo = {CLOBBER};
      procinfo = {CLOBBER};
      spath = {CLOBBER};
    }
}


complete_path (const gunichar2 * appname, gchar * * completed)
{
  int D.17276;
  gchar * D.17279;
  gboolean D.17280;
  int D.17281;
  int D.17284;
  gchar * D.17287;
  gchar * D.17290;
  gchar * utf8app;
  gchar * utf8appmemory;
  gchar * found;

  utf8app = monoeg_g_utf16_to_utf8 (appname, -1, 0B, 0B, 0B);
  utf8appmemory = utf8app;
  D.17276 = monoeg_g_path_is_absolute (utf8app);
  if (D.17276 != 0) goto <D.17277>; else goto <D.17278>;
  <D.17277>:
  D.17279 = quote_path (utf8app);
  *completed = D.17279;
  monoeg_g_free (utf8appmemory);
  D.17280 = 1;
  return D.17280;
  <D.17278>:
  D.17281 = monoeg_g_file_test (utf8app, 8);
  if (D.17281 != 0) goto <D.17282>; else goto <D.17283>;
  <D.17282>:
  D.17284 = monoeg_g_file_test (utf8app, 4);
  if (D.17284 == 0) goto <D.17285>; else goto <D.17286>;
  <D.17285>:
  D.17287 = quote_path (utf8app);
  *completed = D.17287;
  monoeg_g_free (utf8appmemory);
  D.17280 = 1;
  return D.17280;
  <D.17286>:
  <D.17283>:
  found = monoeg_g_find_program_in_path (utf8app);
  if (found == 0B) goto <D.17288>; else goto <D.17289>;
  <D.17288>:
  *completed = 0B;
  monoeg_g_free (utf8appmemory);
  D.17280 = 0;
  return D.17280;
  <D.17289>:
  D.17290 = quote_path (found);
  *completed = D.17290;
  monoeg_g_free (found);
  monoeg_g_free (utf8appmemory);
  D.17280 = 1;
  return D.17280;
}


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

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17294;
  long unsigned int D.17295;

  D.17295 = __builtin_object_size (__dest, 0);
  D.17294 = __builtin___memcpy_chk (__dest, __src, __len, D.17295);
  return D.17294;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_WaitForExit_internal (struct MonoObject * this, void * process, gint32 ms)
{
  unsigned int ms.19;
  MonoBoolean D.17303;
  guint32 ret;

  if (ms < 0) goto <D.17297>; else goto <D.17298>;
  <D.17297>:
  ret = WaitForSingleObjectEx (process, 4294967295, 1);
  goto <D.17299>;
  <D.17298>:
  ms.19 = (unsigned int) ms;
  ret = WaitForSingleObjectEx (process, ms.19, 1);
  <D.17299>:
  if (ret == 0) goto <D.17301>; else goto <D.17302>;
  <D.17301>:
  D.17303 = 1;
  return D.17303;
  <D.17302>:
  D.17303 = 0;
  return D.17303;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_WaitForInputIdle_internal (struct MonoObject * this, void * process, gint32 ms)
{
  unsigned int ms.20;
  MonoBoolean D.17309;
  _Bool D.17310;
  guint32 ret;

  if (ms < 0) goto <D.17305>; else goto <D.17306>;
  <D.17305>:
  ret = WaitForInputIdle (process, 4294967295);
  goto <D.17307>;
  <D.17306>:
  ms.20 = (unsigned int) ms;
  ret = WaitForInputIdle (process, ms.20);
  <D.17307>:
  D.17310 = ret == 0;
  D.17309 = (MonoBoolean) D.17310;
  return D.17309;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_ExitTime_internal (void * process)
{
  unsigned int D.17314;
  long unsigned int D.17315;
  long unsigned int D.17316;
  unsigned int D.17317;
  long unsigned int D.17318;
  long unsigned int D.17319;
  gint64 D.17320;
  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.17312>; else goto <D.17313>;
      <D.17312>:
      D.17314 = exit_time.dwHighDateTime;
      D.17315 = (long unsigned int) D.17314;
      D.17316 = D.17315 << 32;
      D.17317 = exit_time.dwLowDateTime;
      D.17318 = (long unsigned int) D.17317;
      D.17319 = D.17316 + D.17318;
      ticks = (gint64) D.17319;
      D.17320 = ticks;
      return D.17320;
      <D.17313>:
      D.17320 = 0;
      return D.17320;
    }
  finally
    {
      create_time = {CLOBBER};
      exit_time = {CLOBBER};
      kernel_time = {CLOBBER};
      user_time = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_StartTime_internal (void * process)
{
  unsigned int D.17325;
  long unsigned int D.17326;
  long unsigned int D.17327;
  unsigned int D.17328;
  long unsigned int D.17329;
  long unsigned int D.17330;
  gint64 D.17331;
  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.17323>; else goto <D.17324>;
      <D.17323>:
      D.17325 = create_time.dwHighDateTime;
      D.17326 = (long unsigned int) D.17325;
      D.17327 = D.17326 << 32;
      D.17328 = create_time.dwLowDateTime;
      D.17329 = (long unsigned int) D.17328;
      D.17330 = D.17327 + D.17329;
      ticks = (gint64) D.17330;
      D.17331 = ticks;
      return D.17331;
      <D.17324>:
      D.17331 = 0;
      return D.17331;
    }
  finally
    {
      create_time = {CLOBBER};
      exit_time = {CLOBBER};
      kernel_time = {CLOBBER};
      user_time = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_ExitCode_internal (void * process)
{
  gint32 D.17334;
  unsigned int code.21;
  DWORD code;

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


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_ProcessName_internal (void * process)
{
  struct MonoString * D.17340;
  void * mod.22;
  struct MonoDomain * D.17344;
  int len.23;
  struct MonoString * string;
  gboolean ok;
  void * mod;
  gunichar2 name[260];
  DWORD needed;
  guint32 len;

  try
    {
      ok = EnumProcessModules (process, &mod, 8, &needed);
      if (ok == 0) goto <D.17338>; else goto <D.17339>;
      <D.17338>:
      D.17340 = 0B;
      return D.17340;
      <D.17339>:
      mod.22 = mod;
      len = GetModuleBaseName (process, mod.22, &name, 260);
      if (len == 0) goto <D.17342>; else goto <D.17343>;
      <D.17342>:
      D.17340 = 0B;
      return D.17340;
      <D.17343>:
      D.17344 = mono_domain_get ();
      len.23 = (int) len;
      string = mono_string_new_utf16 (D.17344, &name, len.23);
      D.17340 = string;
      return D.17340;
    }
  finally
    {
      mod = {CLOBBER};
      name = {CLOBBER};
      needed = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_GetProcesses_internal ()
{
  long unsigned int D.17348;
  long unsigned int D.17349;
  unsigned int D.17350;
  unsigned int needed.24;
  long unsigned int D.17354;
  unsigned int D.17356;
  struct MonoDomain * D.17357;
  struct MonoClass * D.17358;
  long unsigned int D.17359;
  char * D.17360;
  long unsigned int D.17361;
  struct MonoArray * D.17362;
  struct MonoArray * procs;
  gboolean ret;
  DWORD needed;
  guint32 count;
  guint32 * pids;

  try
    {
      count = 512;
      <D.16888>:
      D.17348 = (long unsigned int) count;
      D.17349 = D.17348 * 4;
      pids = monoeg_malloc0 (D.17349);
      D.17350 = count * 4;
      ret = EnumProcesses (pids, D.17350, &needed);
      if (ret == 0) goto <D.17351>; else goto <D.17352>;
      <D.17351>:
      {
        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.17352>:
      needed.24 = needed;
      D.17354 = (long unsigned int) needed.24;
      D.17348 = (long unsigned int) count;
      D.17349 = D.17348 * 4;
      if (D.17354 < D.17349) goto <D.16887>; else goto <D.17355>;
      <D.17355>:
      monoeg_g_free (pids);
      pids = 0B;
      D.17356 = count * 3;
      count = D.17356 / 2;
      goto <D.16888>;
      <D.16887>:
      needed.24 = needed;
      count = needed.24 / 4;
      D.17357 = mono_domain_get ();
      D.17358 = mono_get_int32_class ();
      D.17359 = (long unsigned int) count;
      procs = mono_array_new (D.17357, D.17358, D.17359);
      D.17360 = mono_array_addr_with_size (procs, 4, 0);
      needed.24 = needed;
      D.17361 = (long unsigned int) needed.24;
      memcpy (D.17360, pids, D.17361);
      monoeg_g_free (pids);
      pids = 0B;
      D.17362 = procs;
      return D.17362;
    }
  finally
    {
      needed = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_GetWorkingSet_internal (void * process, guint32 * min, guint32 * max)
{
  long unsigned int ws_min.25;
  unsigned int D.17366;
  long unsigned int ws_max.26;
  unsigned int D.17368;
  MonoBoolean D.17369;
  gboolean ret;
  SIZE_T ws_min;
  SIZE_T ws_max;

  try
    {
      ret = GetProcessWorkingSetSize (process, &ws_min, &ws_max);
      ws_min.25 = ws_min;
      D.17366 = (unsigned int) ws_min.25;
      *min = D.17366;
      ws_max.26 = ws_max;
      D.17368 = (unsigned int) ws_max.26;
      *max = D.17368;
      D.17369 = (MonoBoolean) ret;
      return D.17369;
    }
  finally
    {
      ws_min = {CLOBBER};
      ws_max = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_SetWorkingSet_internal (void * process, guint32 min, guint32 max, MonoBoolean use_min)
{
  MonoBoolean D.17374;
  long unsigned int ws_min.27;
  long unsigned int ws_max.28;
  long unsigned int ws_min.29;
  long unsigned int ws_max.30;
  gboolean ret;
  SIZE_T ws_min;
  SIZE_T ws_max;

  try
    {
      ret = GetProcessWorkingSetSize (process, &ws_min, &ws_max);
      if (ret == 0) goto <D.17372>; else goto <D.17373>;
      <D.17372>:
      D.17374 = 0;
      return D.17374;
      <D.17373>:
      if (use_min == 1) goto <D.17375>; else goto <D.17376>;
      <D.17375>:
      ws_min.27 = (long unsigned int) min;
      ws_min = ws_min.27;
      goto <D.17378>;
      <D.17376>:
      ws_max.28 = (long unsigned int) max;
      ws_max = ws_max.28;
      <D.17378>:
      ws_min.29 = ws_min;
      ws_max.30 = ws_max;
      ret = SetProcessWorkingSetSize (process, ws_min.29, ws_max.30);
      D.17374 = (MonoBoolean) ret;
      return D.17374;
    }
  finally
    {
      ws_min = {CLOBBER};
      ws_max = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_Kill_internal (void * process, gint32 sig)
{
  MonoBoolean D.17384;
  int D.17385;
  int D.17386;

  D.17385 = -sig;
  D.17386 = TerminateProcess (process, D.17385);
  D.17384 = (MonoBoolean) D.17386;
  return D.17384;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_Times (void * process, gint32 type)
{
  int D.17388;
  gint64 D.17393;
  struct FILETIME * user_time.31;
  struct FILETIME * kernel_time.32;
  long int D.17398;
  long int D.17399;
  struct FILETIME create_time;
  struct FILETIME exit_time;
  struct FILETIME kernel_time;
  struct FILETIME user_time;

  try
    {
      D.17388 = GetProcessTimes (process, &create_time, &exit_time, &kernel_time, &user_time);
      if (D.17388 != 0) goto <D.17389>; else goto <D.17390>;
      <D.17389>:
      if (type == 0) goto <D.17391>; else goto <D.17392>;
      <D.17391>:
      user_time.31 = &user_time;
      D.17393 = MEM[(gint64 *)user_time.31];
      return D.17393;
      <D.17392>:
      if (type == 1) goto <D.17395>; else goto <D.17396>;
      <D.17395>:
      kernel_time.32 = &kernel_time;
      D.17393 = MEM[(gint64 *)kernel_time.32];
      return D.17393;
      <D.17396>:
      kernel_time.32 = &kernel_time;
      D.17398 = MEM[(gint64 *)kernel_time.32];
      user_time.31 = &user_time;
      D.17399 = MEM[(gint64 *)user_time.31];
      D.17393 = D.17398 + D.17399;
      return D.17393;
      <D.17390>:
      D.17393 = 0;
      return D.17393;
    }
  finally
    {
      create_time = {CLOBBER};
      exit_time = {CLOBBER};
      kernel_time = {CLOBBER};
      user_time = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_GetPriorityClass (void * process, gint32 * error)
{
  unsigned int D.17402;
  gint32 iftmp.33;
  unsigned int D.17406;
  gint32 D.17408;
  gint32 ret;

  D.17402 = GetPriorityClass (process);
  ret = (gint32) D.17402;
  if (ret == 0) goto <D.17404>; else goto <D.17405>;
  <D.17404>:
  D.17406 = GetLastError ();
  iftmp.33 = (gint32) D.17406;
  goto <D.17407>;
  <D.17405>:
  iftmp.33 = 0;
  <D.17407>:
  *error = iftmp.33;
  D.17408 = ret;
  return D.17408;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_SetPriorityClass (void * process, gint32 priority_class, gint32 * error)
{
  unsigned int priority_class.34;
  gint32 iftmp.35;
  unsigned int D.17414;
  MonoBoolean D.17416;
  gboolean ret;

  priority_class.34 = (unsigned int) priority_class;
  ret = SetPriorityClass (process, priority_class.34);
  if (ret == 0) goto <D.17412>; else goto <D.17413>;
  <D.17412>:
  D.17414 = GetLastError ();
  iftmp.35 = (gint32) D.17414;
  goto <D.17415>;
  <D.17413>:
  iftmp.35 = 0;
  <D.17415>:
  *error = iftmp.35;
  D.17416 = (MonoBoolean) ret;
  return D.17416;
}


ves_icall_System_Diagnostics_Process_ProcessHandle_duplicate (void * process)
{
  void * D.17418;
  void * D.17419;
  void * D.17420;
  void * ret;

  try
    {
      D.17418 = GetCurrentProcess ();
      D.17419 = GetCurrentProcess ();
      DuplicateHandle (D.17418, process, D.17419, &ret, 2032639, 1, 0);
      D.17420 = ret;
      return D.17420;
    }
  finally
    {
      ret = {CLOBBER};
    }
}


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


__attribute__((visibility ("hidden")))
ves_icall_System_Diagnostics_Process_GetProcessData (int pid, gint32 data_type, gint32 * error)
{
  long int D.17423;
  void * D.17424;
  <unnamed type> data_type.36;
  long int D.17426;
  <unnamed type> perror.37;
  int perror.38;
  gint64 D.17431;
  MonoProcessError perror;
  guint64 res;

  try
    {
      D.17423 = (long int) pid;
      D.17424 = (void *) D.17423;
      data_type.36 = (<unnamed type>) data_type;
      D.17426 = mono_process_get_data_with_error (D.17424, data_type.36, &perror);
      res = (guint64) D.17426;
      if (error != 0B) goto <D.17427>; else goto <D.17428>;
      <D.17427>:
      perror.37 = perror;
      perror.38 = (int) perror.37;
      *error = perror.38;
      <D.17428>:
      D.17431 = (gint64) res;
      return D.17431;
    }
  finally
    {
      perror = {CLOBBER};
    }
}