mutex_is_owned (void * handle)
{
  gboolean D.12738;
  struct _WapiHandle_mutex * mutex_handle.0;
  unsigned int D.12741;
  int D.12743;
  int D.12744;
  long unsigned int D.12746;
  long unsigned int D.12747;
  int D.12748;
  struct _WapiHandle_mutex * mutex_handle;
  gboolean ok;
  static const char __func__[15] = "mutex_is_owned";

  try
    {
      ok = _wapi_lookup_handle (handle, 5, &mutex_handle);
      if (ok == 0) goto <D.12736>; else goto <D.12737>;
      <D.12736>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.12738 = 0;
      return D.12738;
      <D.12737>:
      mutex_handle.0 = mutex_handle;
      D.12741 = mutex_handle.0->recursion;
      if (D.12741 != 0) goto <D.12742>; else goto <D.12739>;
      <D.12742>:
      mutex_handle.0 = mutex_handle;
      D.12743 = mutex_handle.0->pid;
      D.12744 = _wapi_getpid ();
      if (D.12743 == D.12744) goto <D.12745>; else goto <D.12739>;
      <D.12745>:
      mutex_handle.0 = mutex_handle;
      D.12746 = mutex_handle.0->tid;
      D.12747 = pthread_self ();
      D.12748 = pthread_equal (D.12746, D.12747);
      if (D.12748 != 0) goto <D.12749>; else goto <D.12739>;
      <D.12749>:
      D.12738 = 1;
      return D.12738;
      <D.12739>:
      D.12738 = 0;
      return D.12738;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


pthread_equal (pthread_t __thread1, pthread_t __thread2)
{
  int D.12752;
  _Bool D.12753;

  D.12753 = __thread1 == __thread2;
  D.12752 = (int) D.12753;
  return D.12752;
}


mutex_own (void * handle)
{
  gboolean D.12757;
  struct _WapiHandle_mutex * mutex_handle.1;
  int D.12759;
  long unsigned int D.12760;
  unsigned int D.12761;
  unsigned int D.12762;
  struct _WapiHandle_mutex * mutex_handle;
  gboolean ok;
  static const char __func__[10] = "mutex_own";

  try
    {
      ok = _wapi_lookup_handle (handle, 5, &mutex_handle);
      if (ok == 0) goto <D.12755>; else goto <D.12756>;
      <D.12755>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.12757 = 0;
      return D.12757;
      <D.12756>:
      _wapi_thread_own_mutex (handle);
      _wapi_handle_set_signal_state (handle, 0, 0);
      mutex_handle.1 = mutex_handle;
      D.12759 = _wapi_getpid ();
      mutex_handle.1->pid = D.12759;
      mutex_handle.1 = mutex_handle;
      D.12760 = pthread_self ();
      mutex_handle.1->tid = D.12760;
      mutex_handle.1 = mutex_handle;
      D.12761 = mutex_handle.1->recursion;
      D.12762 = D.12761 + 1;
      mutex_handle.1->recursion = D.12762;
      D.12757 = 1;
      return D.12757;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


_wapi_handle_set_signal_state (void * handle, gboolean state, gboolean broadcast)
{
  int iftmp.2;
  <unnamed type> D.12771;
  <unnamed type> D.12773;
  <unnamed type> D.12775;
  <unnamed type> D.12777;
  _Bool D.12778;
  long int D.12779;
  long int D.12780;
  unsigned int D.12783;
  struct _WapiHandleUnshared * D.12784;
  unsigned int D.12785;
  unsigned int D.12786;
  long int D.12789;
  union mono_mutex_t * _wapi_global_signal_mutex.3;
  _Bool D.12795;
  long int D.12796;
  long int D.12797;
  union pthread_cond_t * D.12802;
  union pthread_cond_t * _wapi_global_signal_cond.4;
  guint32 idx;
  struct _WapiHandleUnshared * handle_data;
  int thr_ret;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.12765>; else goto <D.12766>;
  <D.12765>:
  return;
  <D.12766>:
  D.12771 = _wapi_handle_type (handle);
  if (D.12771 == 9) goto <D.12768>; else goto <D.12772>;
  <D.12772>:
  D.12773 = _wapi_handle_type (handle);
  if (D.12773 == 11) goto <D.12768>; else goto <D.12774>;
  <D.12774>:
  D.12775 = _wapi_handle_type (handle);
  if (D.12775 == 12) goto <D.12768>; else goto <D.12776>;
  <D.12776>:
  D.12777 = _wapi_handle_type (handle);
  if (D.12777 == 13) goto <D.12768>; else goto <D.12769>;
  <D.12768>:
  iftmp.2 = 1;
  goto <D.12770>;
  <D.12769>:
  iftmp.2 = 0;
  <D.12770>:
  D.12778 = iftmp.2 != 0;
  D.12779 = (long int) D.12778;
  D.12780 = __builtin_expect (D.12779, 0);
  if (D.12780 != 0) goto <D.12781>; else goto <D.12782>;
  <D.12781>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 132, "!_WAPI_SHARED_HANDLE(_wapi_handle_type (handle))");
  <D.12782>:
  D.12783 = idx / 256;
  D.12784 = _wapi_private_handles[D.12783];
  D.12785 = idx & 255;
  D.12786 = D.12785 * 144;
  handle_data = D.12784 + D.12786;
  if (state == 1) goto <D.12787>; else goto <D.12788>;
  <D.12787>:
  {
    struct __pthread_unwind_buf_t __cancel_buf;
    void (*<Tc1>) (void *) __cancel_routine;
    void * __cancel_arg;
    int __not_first_call;

    try
      {
        __cancel_routine = mono_mutex_unlock_in_cleanup;
        __cancel_arg = _wapi_global_signal_mutex;
        __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0);
        D.12789 = __builtin_expect (__not_first_call, 0);
        if (D.12789 != 0) goto <D.12790>; else goto <D.12791>;
        <D.12790>:
        __cancel_routine (__cancel_arg);
        __pthread_unwind_next (&__cancel_buf);
        <D.12791>:
        __pthread_register_cancel (&__cancel_buf);
        _wapi_global_signal_mutex.3 = _wapi_global_signal_mutex;
        thr_ret = pthread_mutex_lock (_wapi_global_signal_mutex.3);
        if (thr_ret != 0) goto <D.12793>; else goto <D.12794>;
        <D.12793>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d for global signal mutex", thr_ret);
        <D.12794>:
        D.12795 = thr_ret != 0;
        D.12796 = (long int) D.12795;
        D.12797 = __builtin_expect (D.12796, 0);
        if (D.12797 != 0) goto <D.12798>; else goto <D.12799>;
        <D.12798>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 151, "thr_ret == 0");
        <D.12799>:
        handle_data->signalled = state;
        if (broadcast == 1) goto <D.12800>; else goto <D.12801>;
        <D.12800>:
        D.12802 = &handle_data->signal_cond;
        thr_ret = pthread_cond_broadcast (D.12802);
        if (thr_ret != 0) goto <D.12803>; else goto <D.12804>;
        <D.12803>:
        monoeg_g_log (0B, 16, "Bad call to pthread_cond_broadcast result %d for handle %p", thr_ret, handle);
        <D.12804>:
        D.12795 = thr_ret != 0;
        D.12796 = (long int) D.12795;
        D.12797 = __builtin_expect (D.12796, 0);
        if (D.12797 != 0) goto <D.12805>; else goto <D.12806>;
        <D.12805>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 162, "thr_ret == 0");
        <D.12806>:
        goto <D.12807>;
        <D.12801>:
        D.12802 = &handle_data->signal_cond;
        thr_ret = pthread_cond_signal (D.12802);
        if (thr_ret != 0) goto <D.12808>; else goto <D.12809>;
        <D.12808>:
        monoeg_g_log (0B, 16, "Bad call to pthread_cond_signal result %d for handle %p", thr_ret, handle);
        <D.12809>:
        D.12795 = thr_ret != 0;
        D.12796 = (long int) D.12795;
        D.12797 = __builtin_expect (D.12796, 0);
        if (D.12797 != 0) goto <D.12810>; else goto <D.12811>;
        <D.12810>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 167, "thr_ret == 0");
        <D.12811>:
        <D.12807>:
        _wapi_global_signal_cond.4 = _wapi_global_signal_cond;
        thr_ret = pthread_cond_broadcast (_wapi_global_signal_cond.4);
        if (thr_ret != 0) goto <D.12813>; else goto <D.12814>;
        <D.12813>:
        monoeg_g_log (0B, 16, "Bad call to pthread_cond_broadcast result %d for handle %p", thr_ret, handle);
        <D.12814>:
        D.12795 = thr_ret != 0;
        D.12796 = (long int) D.12795;
        D.12797 = __builtin_expect (D.12796, 0);
        if (D.12797 != 0) goto <D.12815>; else goto <D.12816>;
        <D.12815>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 176, "thr_ret == 0");
        <D.12816>:
        _wapi_global_signal_mutex.3 = _wapi_global_signal_mutex;
        thr_ret = pthread_mutex_unlock (_wapi_global_signal_mutex.3);
        if (thr_ret != 0) goto <D.12817>; else goto <D.12818>;
        <D.12817>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d for global signal mutex", thr_ret);
        <D.12818>:
        D.12795 = thr_ret != 0;
        D.12796 = (long int) D.12795;
        D.12797 = __builtin_expect (D.12796, 0);
        if (D.12797 != 0) goto <D.12819>; else goto <D.12820>;
        <D.12819>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 181, "thr_ret == 0");
        <D.12820>:
        __pthread_unregister_cancel (&__cancel_buf);
        if (0 != 0) goto <D.12821>; else goto <D.12822>;
        <D.12821>:
        __cancel_routine (__cancel_arg);
        <D.12822>:
      }
    finally
      {
        __cancel_buf = {CLOBBER};
      }
  }
  goto <D.12823>;
  <D.12788>:
  handle_data->signalled = state;
  <D.12823>:
}


mono_mutex_unlock_in_cleanup (union mono_mutex_t * mutex)
{
  int D.12834;

  D.12834 = pthread_mutex_unlock (mutex);
  return D.12834;
}


_wapi_handle_type (void * handle)
{
  unsigned int D.12839;
  struct _WapiHandleUnshared * D.12840;
  WapiHandleType D.12841;
  unsigned int D.12842;
  unsigned int D.12843;
  struct _WapiHandleUnshared * D.12844;
  guint32 idx;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.12836>; else goto <D.12838>;
  <D.12838>:
  D.12839 = idx / 256;
  D.12840 = _wapi_private_handles[D.12839];
  if (D.12840 == 0B) goto <D.12836>; else goto <D.12837>;
  <D.12836>:
  D.12841 = 0;
  return D.12841;
  <D.12837>:
  D.12839 = idx / 256;
  D.12840 = _wapi_private_handles[D.12839];
  D.12842 = idx & 255;
  D.12843 = D.12842 * 144;
  D.12844 = D.12840 + D.12843;
  D.12841 = D.12844->type;
  return D.12841;
}


mutex_signal (void * handle)
{
  ReleaseMutex (handle);
}


_wapi_mutex_details (void * handle_info)
{
  int D.12846;
  long unsigned int D.12847;
  unsigned int D.12848;
  struct _WapiHandle_mutex * mut;

  mut = handle_info;
  D.12846 = mut->pid;
  D.12847 = mut->tid;
  D.12848 = mut->recursion;
  monoeg_g_print ("own: %5d:%5ld, count: %5u", D.12846, D.12847, D.12848);
}


namedmutex_prewait (void * handle)
{
  struct _WapiHandle_namedmutex * namedmutex_handle.5;
  unsigned int D.12852;
  int D.12856;
  int D.12857;
  unsigned int D.12861;
  _Bool D.12864;
  long int D.12865;
  long int D.12866;
  struct _WapiHandle_namedmutex * namedmutex_handle;
  gboolean ok;
  static const char __func__[19] = "namedmutex_prewait";

  try
    {
      ok = _wapi_lookup_handle (handle, 11, &namedmutex_handle);
      if (ok == 0) goto <D.12849>; else goto <D.12850>;
      <D.12849>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      return;
      <D.12850>:
      namedmutex_handle.5 = namedmutex_handle;
      D.12852 = namedmutex_handle.5->recursion;
      if (D.12852 == 0) goto <D.12853>; else goto <D.12854>;
      <D.12853>:
      goto <D.12855>;
      <D.12854>:
      namedmutex_handle.5 = namedmutex_handle;
      D.12856 = namedmutex_handle.5->pid;
      D.12857 = _wapi_getpid ();
      if (D.12856 == D.12857) goto <D.12858>; else goto <D.12859>;
      <D.12858>:
      goto <D.12860>;
      <D.12859>:
      {
        int thr_ret;
        void * proc_handle;

        namedmutex_handle.5 = namedmutex_handle;
        D.12856 = namedmutex_handle.5->pid;
        D.12861 = (unsigned int) D.12856;
        proc_handle = OpenProcess (0, 0, D.12861);
        if (proc_handle == 0B) goto <D.12862>; else goto <D.12863>;
        <D.12862>:
        thr_ret = _wapi_handle_lock_shared_handles ();
        D.12864 = thr_ret != 0;
        D.12865 = (long int) D.12864;
        D.12866 = __builtin_expect (D.12865, 0);
        if (D.12866 != 0) goto <D.12867>; else goto <D.12868>;
        <D.12867>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 274, "thr_ret == 0");
        <D.12868>:
        namedmutex_handle.5 = namedmutex_handle;
        namedmutex_handle.5->pid = 0;
        namedmutex_handle.5 = namedmutex_handle;
        namedmutex_handle.5->tid = 0;
        namedmutex_handle.5 = namedmutex_handle;
        namedmutex_handle.5->recursion = 0;
        _wapi_shared_handle_set_signal_state (handle, 1);
        _wapi_handle_unlock_shared_handles ();
        goto <D.12869>;
        <D.12863>:
        <D.12869>:
        if (proc_handle != 0B) goto <D.12870>; else goto <D.12871>;
        <D.12870>:
        CloseProcess (proc_handle);
        <D.12871>:
      }
      <D.12860>:
      <D.12855>:
    }
  finally
    {
      namedmutex_handle = {CLOBBER};
    }
}


_wapi_handle_lock_shared_handles ()
{
  int D.12875;

  D.12875 = _wapi_shm_sem_lock (3);
  return D.12875;
}


_wapi_shared_handle_set_signal_state (void * handle, gboolean state)
{
  int iftmp.6;
  <unnamed type> D.12882;
  <unnamed type> D.12884;
  <unnamed type> D.12886;
  <unnamed type> D.12888;
  _Bool D.12890;
  long int D.12891;
  long int D.12892;
  unsigned int D.12895;
  struct _WapiHandleUnshared * D.12896;
  unsigned int D.12897;
  unsigned int D.12898;
  struct _WapiHandleSharedLayout * _wapi_shared_layout.7;
  unsigned int D.12900;
  guint32 idx;
  struct _WapiHandleUnshared * handle_data;
  struct _WapiHandle_shared_ref * ref;
  struct _WapiHandleShared * shared_data;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.12877>; else goto <D.12878>;
  <D.12877>:
  return;
  <D.12878>:
  D.12882 = _wapi_handle_type (handle);
  if (D.12882 != 9) goto <D.12883>; else goto <D.12880>;
  <D.12883>:
  D.12884 = _wapi_handle_type (handle);
  if (D.12884 != 11) goto <D.12885>; else goto <D.12880>;
  <D.12885>:
  D.12886 = _wapi_handle_type (handle);
  if (D.12886 != 12) goto <D.12887>; else goto <D.12880>;
  <D.12887>:
  D.12888 = _wapi_handle_type (handle);
  if (D.12888 != 13) goto <D.12889>; else goto <D.12880>;
  <D.12889>:
  iftmp.6 = 1;
  goto <D.12881>;
  <D.12880>:
  iftmp.6 = 0;
  <D.12881>:
  D.12890 = iftmp.6 != 0;
  D.12891 = (long int) D.12890;
  D.12892 = __builtin_expect (D.12891, 0);
  if (D.12892 != 0) goto <D.12893>; else goto <D.12894>;
  <D.12893>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 201, "_WAPI_SHARED_HANDLE(_wapi_handle_type (handle))");
  <D.12894>:
  D.12895 = idx / 256;
  D.12896 = _wapi_private_handles[D.12895];
  D.12897 = idx & 255;
  D.12898 = D.12897 * 144;
  handle_data = D.12896 + D.12898;
  ref = &handle_data->u.shared;
  _wapi_shared_layout.7 = _wapi_shared_layout;
  D.12900 = ref->offset;
  shared_data = &_wapi_shared_layout.7->handles[D.12900];
  shared_data->signalled = state;
}


_wapi_handle_unlock_shared_handles ()
{
  int D.12902;

  D.12902 = _wapi_shm_sem_unlock (3);
  return D.12902;
}


namedmutex_is_owned (void * handle)
{
  gboolean D.12906;
  struct _WapiHandle_namedmutex * namedmutex_handle.8;
  unsigned int D.12909;
  int D.12911;
  int D.12912;
  long unsigned int D.12914;
  long unsigned int D.12915;
  int D.12916;
  struct _WapiHandle_namedmutex * namedmutex_handle;
  gboolean ok;
  static const char __func__[20] = "namedmutex_is_owned";

  try
    {
      ok = _wapi_lookup_handle (handle, 11, &namedmutex_handle);
      if (ok == 0) goto <D.12904>; else goto <D.12905>;
      <D.12904>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.12906 = 0;
      return D.12906;
      <D.12905>:
      namedmutex_handle.8 = namedmutex_handle;
      D.12909 = namedmutex_handle.8->recursion;
      if (D.12909 != 0) goto <D.12910>; else goto <D.12907>;
      <D.12910>:
      namedmutex_handle.8 = namedmutex_handle;
      D.12911 = namedmutex_handle.8->pid;
      D.12912 = _wapi_getpid ();
      if (D.12911 == D.12912) goto <D.12913>; else goto <D.12907>;
      <D.12913>:
      namedmutex_handle.8 = namedmutex_handle;
      D.12914 = namedmutex_handle.8->tid;
      D.12915 = pthread_self ();
      D.12916 = pthread_equal (D.12914, D.12915);
      if (D.12916 != 0) goto <D.12917>; else goto <D.12907>;
      <D.12917>:
      D.12906 = 1;
      return D.12906;
      <D.12907>:
      D.12906 = 0;
      return D.12906;
    }
  finally
    {
      namedmutex_handle = {CLOBBER};
    }
}


namedmutex_own (void * handle)
{
  gboolean D.12922;
  struct _WapiHandle_namedmutex * namedmutex_handle.9;
  int D.12924;
  long unsigned int D.12925;
  unsigned int D.12926;
  unsigned int D.12927;
  struct _WapiHandle_namedmutex * namedmutex_handle;
  gboolean ok;
  static const char __func__[15] = "namedmutex_own";

  try
    {
      ok = _wapi_lookup_handle (handle, 11, &namedmutex_handle);
      if (ok == 0) goto <D.12920>; else goto <D.12921>;
      <D.12920>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      D.12922 = 0;
      return D.12922;
      <D.12921>:
      _wapi_thread_own_mutex (handle);
      namedmutex_handle.9 = namedmutex_handle;
      D.12924 = _wapi_getpid ();
      namedmutex_handle.9->pid = D.12924;
      namedmutex_handle.9 = namedmutex_handle;
      D.12925 = pthread_self ();
      namedmutex_handle.9->tid = D.12925;
      namedmutex_handle.9 = namedmutex_handle;
      D.12926 = namedmutex_handle.9->recursion;
      D.12927 = D.12926 + 1;
      namedmutex_handle.9->recursion = D.12927;
      _wapi_shared_handle_set_signal_state (handle, 0);
      D.12922 = 1;
      return D.12922;
    }
  finally
    {
      namedmutex_handle = {CLOBBER};
    }
}


namedmutex_signal (void * handle)
{
  ReleaseMutex (handle);
}


_wapi_mutex_abandon (void * data, pid_t pid, pthread_t tid)
{
  WapiHandleType type;

  type = _wapi_handle_type (data);
  if (type == 5) goto <D.12930>; else goto <D.12931>;
  <D.12930>:
  mutex_abandon (data, pid, tid);
  goto <D.12932>;
  <D.12931>:
  if (type == 11) goto <D.12933>; else goto <D.12934>;
  <D.12933>:
  namedmutex_abandon (data, pid, tid);
  goto <D.12935>;
  <D.12934>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mutexes.c", 369);
  <D.12935>:
  <D.12932>:
}


mutex_abandon (void * handle, pid_t pid, pthread_t tid)
{
  long int D.12938;
  _Bool D.12941;
  long int D.12942;
  long int D.12943;
  struct _WapiHandle_mutex * mutex_handle.10;
  int D.12947;
  long unsigned int D.12950;
  int D.12951;
  struct _WapiHandle_mutex * mutex_handle;
  gboolean ok;
  int thr_ret;
  static const char __func__[14] = "mutex_abandon";

  try
    {
      ok = _wapi_lookup_handle (handle, 5, &mutex_handle);
      if (ok == 0) goto <D.12936>; else goto <D.12937>;
      <D.12936>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      return;
      <D.12937>:
      {
        struct __pthread_unwind_buf_t __cancel_buf;
        void (*<Tc1>) (void *) __cancel_routine;
        void * __cancel_arg;
        int __not_first_call;

        try
          {
            __cancel_routine = _wapi_handle_unlock_handle;
            __cancel_arg = handle;
            __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0);
            D.12938 = __builtin_expect (__not_first_call, 0);
            if (D.12938 != 0) goto <D.12939>; else goto <D.12940>;
            <D.12939>:
            __cancel_routine (__cancel_arg);
            __pthread_unwind_next (&__cancel_buf);
            <D.12940>:
            __pthread_register_cancel (&__cancel_buf);
            thr_ret = _wapi_handle_lock_handle (handle);
            D.12941 = thr_ret != 0;
            D.12942 = (long int) D.12941;
            D.12943 = __builtin_expect (D.12942, 0);
            if (D.12943 != 0) goto <D.12944>; else goto <D.12945>;
            <D.12944>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 307, "thr_ret == 0");
            <D.12945>:
            mutex_handle.10 = mutex_handle;
            D.12947 = mutex_handle.10->pid;
            if (D.12947 == pid) goto <D.12948>; else goto <D.12949>;
            <D.12948>:
            mutex_handle.10 = mutex_handle;
            D.12950 = mutex_handle.10->tid;
            D.12951 = pthread_equal (D.12950, tid);
            if (D.12951 != 0) goto <D.12952>; else goto <D.12953>;
            <D.12952>:
            mutex_handle.10 = mutex_handle;
            mutex_handle.10->recursion = 0;
            mutex_handle.10 = mutex_handle;
            mutex_handle.10->pid = 0;
            mutex_handle.10 = mutex_handle;
            mutex_handle.10->tid = 0;
            _wapi_handle_set_signal_state (handle, 1, 0);
            <D.12953>:
            <D.12949>:
            thr_ret = _wapi_handle_unlock_handle (handle);
            D.12941 = thr_ret != 0;
            D.12942 = (long int) D.12941;
            D.12943 = __builtin_expect (D.12942, 0);
            if (D.12943 != 0) goto <D.12954>; else goto <D.12955>;
            <D.12954>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 321, "thr_ret == 0");
            <D.12955>:
            __pthread_unregister_cancel (&__cancel_buf);
            if (0 != 0) goto <D.12956>; else goto <D.12957>;
            <D.12956>:
            __cancel_routine (__cancel_arg);
            <D.12957>:
          }
        finally
          {
            __cancel_buf = {CLOBBER};
          }
      }
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


_wapi_handle_lock_handle (void * handle)
{
  int D.12966;
  <unnamed type> D.12969;
  <unnamed type> D.12971;
  <unnamed type> D.12973;
  <unnamed type> D.12975;
  unsigned int D.12976;
  struct _WapiHandleUnshared * D.12977;
  unsigned int D.12978;
  unsigned int D.12979;
  struct _WapiHandleUnshared * D.12980;
  union mono_mutex_t * D.12981;
  guint32 idx;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.12964>; else goto <D.12965>;
  <D.12964>:
  D.12966 = 0;
  return D.12966;
  <D.12965>:
  _wapi_handle_ref (handle);
  D.12969 = _wapi_handle_type (handle);
  if (D.12969 == 9) goto <D.12967>; else goto <D.12970>;
  <D.12970>:
  D.12971 = _wapi_handle_type (handle);
  if (D.12971 == 11) goto <D.12967>; else goto <D.12972>;
  <D.12972>:
  D.12973 = _wapi_handle_type (handle);
  if (D.12973 == 12) goto <D.12967>; else goto <D.12974>;
  <D.12974>:
  D.12975 = _wapi_handle_type (handle);
  if (D.12975 == 13) goto <D.12967>; else goto <D.12968>;
  <D.12967>:
  D.12966 = 0;
  return D.12966;
  <D.12968>:
  D.12976 = idx / 256;
  D.12977 = _wapi_private_handles[D.12976];
  D.12978 = idx & 255;
  D.12979 = D.12978 * 144;
  D.12980 = D.12977 + D.12979;
  D.12981 = &D.12980->signal_mutex;
  D.12966 = pthread_mutex_lock (D.12981);
  return D.12966;
}


_wapi_handle_unlock_handle (void * handle)
{
  int D.12985;
  <unnamed type> D.12988;
  <unnamed type> D.12990;
  <unnamed type> D.12992;
  <unnamed type> D.12994;
  unsigned int D.12995;
  struct _WapiHandleUnshared * D.12996;
  unsigned int D.12997;
  unsigned int D.12998;
  struct _WapiHandleUnshared * D.12999;
  union mono_mutex_t * D.13000;
  guint32 idx;
  int ret;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.12983>; else goto <D.12984>;
  <D.12983>:
  D.12985 = 0;
  return D.12985;
  <D.12984>:
  D.12988 = _wapi_handle_type (handle);
  if (D.12988 == 9) goto <D.12986>; else goto <D.12989>;
  <D.12989>:
  D.12990 = _wapi_handle_type (handle);
  if (D.12990 == 11) goto <D.12986>; else goto <D.12991>;
  <D.12991>:
  D.12992 = _wapi_handle_type (handle);
  if (D.12992 == 12) goto <D.12986>; else goto <D.12993>;
  <D.12993>:
  D.12994 = _wapi_handle_type (handle);
  if (D.12994 == 13) goto <D.12986>; else goto <D.12987>;
  <D.12986>:
  _wapi_handle_unref (handle);
  D.12985 = 0;
  return D.12985;
  <D.12987>:
  D.12995 = idx / 256;
  D.12996 = _wapi_private_handles[D.12995];
  D.12997 = idx & 255;
  D.12998 = D.12997 * 144;
  D.12999 = D.12996 + D.12998;
  D.13000 = &D.12999->signal_mutex;
  ret = pthread_mutex_unlock (D.13000);
  _wapi_handle_unref (handle);
  D.12985 = ret;
  return D.12985;
}


namedmutex_abandon (void * handle, pid_t pid, pthread_t tid)
{
  _Bool D.13004;
  long int D.13005;
  long int D.13006;
  struct _WapiHandle_namedmutex * mutex_handle.11;
  int D.13010;
  long unsigned int D.13013;
  int D.13014;
  struct _WapiHandle_namedmutex * mutex_handle;
  gboolean ok;
  int thr_ret;
  static const char __func__[19] = "namedmutex_abandon";

  try
    {
      ok = _wapi_lookup_handle (handle, 11, &mutex_handle);
      if (ok == 0) goto <D.13002>; else goto <D.13003>;
      <D.13002>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      return;
      <D.13003>:
      thr_ret = _wapi_handle_lock_shared_handles ();
      D.13004 = thr_ret != 0;
      D.13005 = (long int) D.13004;
      D.13006 = __builtin_expect (D.13005, 0);
      if (D.13006 != 0) goto <D.13007>; else goto <D.13008>;
      <D.13007>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 340, "thr_ret == 0");
      <D.13008>:
      mutex_handle.11 = mutex_handle;
      D.13010 = mutex_handle.11->pid;
      if (D.13010 == pid) goto <D.13011>; else goto <D.13012>;
      <D.13011>:
      mutex_handle.11 = mutex_handle;
      D.13013 = mutex_handle.11->tid;
      D.13014 = pthread_equal (D.13013, tid);
      if (D.13014 != 0) goto <D.13015>; else goto <D.13016>;
      <D.13015>:
      mutex_handle.11 = mutex_handle;
      mutex_handle.11->recursion = 0;
      mutex_handle.11 = mutex_handle;
      mutex_handle.11->pid = 0;
      mutex_handle.11 = mutex_handle;
      mutex_handle.11->tid = 0;
      _wapi_shared_handle_set_signal_state (handle, 1);
      <D.13016>:
      <D.13012>:
      _wapi_handle_unlock_shared_handles ();
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


CreateMutex (struct WapiSecurityAttributes * security, gboolean owned, const gunichar2 * name)
{
  void * D.13022;

  mono_once (&mutex_ops_once, mutex_ops_init);
  if (name == 0B) goto <D.13020>; else goto <D.13021>;
  <D.13020>:
  D.13022 = mutex_create (security, owned);
  return D.13022;
  <D.13021>:
  D.13022 = namedmutex_create (security, owned, name);
  return D.13022;
}


mutex_ops_init ()
{
  _wapi_handle_register_capabilities (5, 7);
  _wapi_handle_register_capabilities (11, 7);
}


mutex_create (struct WapiSecurityAttributes * security, gboolean owned)
{
  void * D.13026;
  long int D.13027;
  _Bool D.13030;
  long int D.13031;
  long int D.13032;
  struct _WapiHandle_mutex mutex_handle;
  void * handle;
  int thr_ret;
  static const char __func__[13] = "mutex_create";

  try
    {
      mutex_handle = {};
      SetLastError (0);
      handle = _wapi_handle_new (5, &mutex_handle);
      if (handle == 4294967295B) goto <D.13024>; else goto <D.13025>;
      <D.13024>:
      monoeg_g_log (0B, 16, "%s: error creating mutex handle", &__func__);
      SetLastError (31);
      D.13026 = 0B;
      return D.13026;
      <D.13025>:
      {
        struct __pthread_unwind_buf_t __cancel_buf;
        void (*<Tc1>) (void *) __cancel_routine;
        void * __cancel_arg;
        int __not_first_call;

        try
          {
            __cancel_routine = _wapi_handle_unlock_handle;
            __cancel_arg = handle;
            __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0);
            D.13027 = __builtin_expect (__not_first_call, 0);
            if (D.13027 != 0) goto <D.13028>; else goto <D.13029>;
            <D.13028>:
            __cancel_routine (__cancel_arg);
            __pthread_unwind_next (&__cancel_buf);
            <D.13029>:
            __pthread_register_cancel (&__cancel_buf);
            thr_ret = _wapi_handle_lock_handle (handle);
            D.13030 = thr_ret != 0;
            D.13031 = (long int) D.13030;
            D.13032 = __builtin_expect (D.13031, 0);
            if (D.13032 != 0) goto <D.13033>; else goto <D.13034>;
            <D.13033>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 398, "thr_ret == 0");
            <D.13034>:
            if (owned == 1) goto <D.13035>; else goto <D.13036>;
            <D.13035>:
            mutex_own (handle);
            goto <D.13037>;
            <D.13036>:
            _wapi_handle_set_signal_state (handle, 1, 0);
            <D.13037>:
            thr_ret = _wapi_handle_unlock_handle (handle);
            D.13030 = thr_ret != 0;
            D.13031 = (long int) D.13030;
            D.13032 = __builtin_expect (D.13031, 0);
            if (D.13032 != 0) goto <D.13038>; else goto <D.13039>;
            <D.13038>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 409, "thr_ret == 0");
            <D.13039>:
            __pthread_unregister_cancel (&__cancel_buf);
            if (0 != 0) goto <D.13040>; else goto <D.13041>;
            <D.13040>:
            __cancel_routine (__cancel_arg);
            <D.13041>:
          }
        finally
          {
            __cancel_buf = {CLOBBER};
          }
      }
      D.13026 = handle;
      return D.13026;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


namedmutex_create (struct WapiSecurityAttributes * security, gboolean owned, const gunichar2 * name)
{
  _Bool D.13047;
  long int D.13048;
  long int D.13049;
  unsigned int D.13058;
  unsigned int offset.12;
  void * D.13073;
  struct _WapiHandle_namedmutex namedmutex_handle;
  void * handle;
  gchar * utf8_name;
  int thr_ret;
  void * ret;
  guint32 namelen;
  gint32 offset;
  void cleanup = <<< error >>>;
  static const char __func__[18] = "namedmutex_create";

  try
    {
      namedmutex_handle = {};
      ret = 0B;
      thr_ret = _wapi_namespace_lock ();
      D.13047 = thr_ret != 0;
      D.13048 = (long int) D.13047;
      D.13049 = __builtin_expect (D.13048, 0);
      if (D.13049 != 0) goto <D.13050>; else goto <D.13051>;
      <D.13050>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 430, "thr_ret == 0");
      <D.13051>:
      SetLastError (0);
      utf8_name = monoeg_g_utf16_to_utf8 (name, -1, 0B, 0B, 0B);
      offset = _wapi_search_handle_namespace (11, utf8_name);
      if (offset == -1) goto <D.13052>; else goto <D.13053>;
      <D.13052>:
      SetLastError (6);
      goto cleanup;
      <D.13053>:
      if (offset != 0) goto <D.13054>; else goto <D.13055>;
      <D.13054>:
      SetLastError (183);
      <D.13055>:
      if (offset == 0) goto <D.13056>; else goto <D.13057>;
      <D.13056>:
      D.13058 = strlen (utf8_name);
      if (D.13058 <= 259) goto <D.13059>; else goto <D.13060>;
      <D.13059>:
      namelen = strlen (utf8_name);
      goto <D.13061>;
      <D.13060>:
      namelen = 260;
      <D.13061>:
      memcpy (&namedmutex_handle.sharedns.name, utf8_name, namelen);
      handle = _wapi_handle_new (11, &namedmutex_handle);
      goto <D.13062>;
      <D.13057>:
      offset.12 = (unsigned int) offset;
      handle = _wapi_handle_new_from_offset (11, offset.12, 1);
      <D.13062>:
      if (handle == 4294967295B) goto <D.13064>; else goto <D.13065>;
      <D.13064>:
      monoeg_g_log (0B, 16, "%s: error creating mutex handle", &__func__);
      SetLastError (31);
      goto cleanup;
      <D.13065>:
      ret = handle;
      if (offset == 0) goto <D.13066>; else goto <D.13067>;
      <D.13066>:
      thr_ret = _wapi_handle_lock_shared_handles ();
      D.13047 = thr_ret != 0;
      D.13048 = (long int) D.13047;
      D.13049 = __builtin_expect (D.13048, 0);
      if (D.13049 != 0) goto <D.13068>; else goto <D.13069>;
      <D.13068>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 493, "thr_ret == 0");
      <D.13069>:
      if (owned == 1) goto <D.13070>; else goto <D.13071>;
      <D.13070>:
      namedmutex_own (handle);
      goto <D.13072>;
      <D.13071>:
      _wapi_shared_handle_set_signal_state (handle, 1);
      <D.13072>:
      _wapi_handle_unlock_shared_handles ();
      <D.13067>:
      cleanup:
      monoeg_g_free (utf8_name);
      _wapi_namespace_unlock (0B);
      D.13073 = ret;
      return D.13073;
    }
  finally
    {
      namedmutex_handle = {CLOBBER};
    }
}


_wapi_namespace_lock ()
{
  int D.13076;

  D.13076 = _wapi_shm_sem_lock (0);
  return D.13076;
}


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

  D.13079 = __builtin_object_size (__dest, 0);
  D.13078 = __builtin___memcpy_chk (__dest, __src, __len, D.13079);
  return D.13078;
}


_wapi_namespace_unlock (void * data)
{
  int D.13081;

  D.13081 = _wapi_shm_sem_unlock (0);
  return D.13081;
}


ReleaseMutex (void * handle)
{
  gboolean D.13085;
  gboolean (*<T1fe7>) (void *) D.13086;
  WapiHandleType type;

  if (handle == 0B) goto <D.13083>; else goto <D.13084>;
  <D.13083>:
  SetLastError (6);
  D.13085 = 0;
  return D.13085;
  <D.13084>:
  type = _wapi_handle_type (handle);
  D.13086 = mutex_ops[type].release;
  if (D.13086 == 0B) goto <D.13087>; else goto <D.13088>;
  <D.13087>:
  SetLastError (6);
  D.13085 = 0;
  return D.13085;
  <D.13088>:
  D.13086 = mutex_ops[type].release;
  D.13085 = D.13086 (handle);
  return D.13085;
}


namedmutex_release (void * handle)
{
  gboolean D.13092;
  _Bool D.13093;
  long int D.13094;
  long int D.13095;
  struct _WapiHandle_namedmutex * mutex_handle.13;
  long unsigned int D.13099;
  int D.13100;
  int D.13102;
  unsigned int D.13104;
  unsigned int D.13105;
  struct _WapiHandle_namedmutex * mutex_handle;
  gboolean ok;
  pthread_t tid;
  pid_t pid;
  int thr_ret;
  gboolean ret;
  static const char __func__[19] = "namedmutex_release";
  void cleanup = <<< error >>>;

  try
    {
      tid = pthread_self ();
      pid = _wapi_getpid ();
      ret = 0;
      ok = _wapi_lookup_handle (handle, 11, &mutex_handle);
      if (ok == 0) goto <D.13090>; else goto <D.13091>;
      <D.13090>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      D.13092 = 0;
      return D.13092;
      <D.13091>:
      thr_ret = _wapi_handle_lock_shared_handles ();
      D.13093 = thr_ret != 0;
      D.13094 = (long int) D.13093;
      D.13095 = __builtin_expect (D.13094, 0);
      if (D.13095 != 0) goto <D.13096>; else goto <D.13097>;
      <D.13096>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 616, "thr_ret == 0");
      <D.13097>:
      mutex_handle.13 = mutex_handle;
      D.13099 = mutex_handle.13->tid;
      D.13100 = pthread_equal (D.13099, tid);
      if (D.13100 == 0) goto cleanup; else goto <D.13101>;
      <D.13101>:
      mutex_handle.13 = mutex_handle;
      D.13102 = mutex_handle.13->pid;
      if (D.13102 != pid) goto cleanup; else goto <D.13103>;
      <D.13103>:
      ret = 1;
      mutex_handle.13 = mutex_handle;
      D.13104 = mutex_handle.13->recursion;
      D.13105 = D.13104 + 4294967295;
      mutex_handle.13->recursion = D.13105;
      mutex_handle.13 = mutex_handle;
      D.13104 = mutex_handle.13->recursion;
      if (D.13104 == 0) goto <D.13106>; else goto <D.13107>;
      <D.13106>:
      _wapi_thread_disown_mutex (handle);
      mutex_handle.13 = mutex_handle;
      mutex_handle.13->pid = 0;
      mutex_handle.13 = mutex_handle;
      mutex_handle.13->tid = 0;
      _wapi_shared_handle_set_signal_state (handle, 1);
      <D.13107>:
      cleanup:
      _wapi_handle_unlock_shared_handles ();
      D.13092 = ret;
      return D.13092;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


mutex_release (void * handle)
{
  gboolean D.13112;
  long int D.13113;
  _Bool D.13116;
  long int D.13117;
  long int D.13118;
  struct _WapiHandle_mutex * mutex_handle.14;
  long unsigned int D.13122;
  int D.13123;
  int D.13125;
  unsigned int D.13127;
  unsigned int D.13128;
  struct _WapiHandle_mutex * mutex_handle;
  gboolean ok;
  pthread_t tid;
  pid_t pid;
  int thr_ret;
  gboolean ret;
  static const char __func__[14] = "mutex_release";
  void cleanup = <<< error >>>;

  try
    {
      tid = pthread_self ();
      pid = _wapi_getpid ();
      ret = 0;
      ok = _wapi_lookup_handle (handle, 5, &mutex_handle);
      if (ok == 0) goto <D.13110>; else goto <D.13111>;
      <D.13110>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.13112 = 0;
      return D.13112;
      <D.13111>:
      {
        struct __pthread_unwind_buf_t __cancel_buf;
        void (*<Tc1>) (void *) __cancel_routine;
        void * __cancel_arg;
        int __not_first_call;

        try
          {
            __cancel_routine = _wapi_handle_unlock_handle;
            __cancel_arg = handle;
            __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0);
            D.13113 = __builtin_expect (__not_first_call, 0);
            if (D.13113 != 0) goto <D.13114>; else goto <D.13115>;
            <D.13114>:
            __cancel_routine (__cancel_arg);
            __pthread_unwind_next (&__cancel_buf);
            <D.13115>:
            __pthread_register_cancel (&__cancel_buf);
            thr_ret = _wapi_handle_lock_handle (handle);
            D.13116 = thr_ret != 0;
            D.13117 = (long int) D.13116;
            D.13118 = __builtin_expect (D.13117, 0);
            if (D.13118 != 0) goto <D.13119>; else goto <D.13120>;
            <D.13119>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 565, "thr_ret == 0");
            <D.13120>:
            mutex_handle.14 = mutex_handle;
            D.13122 = mutex_handle.14->tid;
            D.13123 = pthread_equal (D.13122, tid);
            if (D.13123 == 0) goto cleanup; else goto <D.13124>;
            <D.13124>:
            mutex_handle.14 = mutex_handle;
            D.13125 = mutex_handle.14->pid;
            if (D.13125 != pid) goto cleanup; else goto <D.13126>;
            <D.13126>:
            ret = 1;
            mutex_handle.14 = mutex_handle;
            D.13127 = mutex_handle.14->recursion;
            D.13128 = D.13127 + 4294967295;
            mutex_handle.14->recursion = D.13128;
            mutex_handle.14 = mutex_handle;
            D.13127 = mutex_handle.14->recursion;
            if (D.13127 == 0) goto <D.13129>; else goto <D.13130>;
            <D.13129>:
            _wapi_thread_disown_mutex (handle);
            mutex_handle.14 = mutex_handle;
            mutex_handle.14->pid = 0;
            mutex_handle.14 = mutex_handle;
            mutex_handle.14->tid = 0;
            _wapi_handle_set_signal_state (handle, 1, 0);
            <D.13130>:
            cleanup:
            thr_ret = _wapi_handle_unlock_handle (handle);
            D.13116 = thr_ret != 0;
            D.13117 = (long int) D.13116;
            D.13118 = __builtin_expect (D.13117, 0);
            if (D.13118 != 0) goto <D.13131>; else goto <D.13132>;
            <D.13131>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 592, "thr_ret == 0");
            <D.13132>:
            __pthread_unregister_cancel (&__cancel_buf);
            if (0 != 0) goto <D.13133>; else goto <D.13134>;
            <D.13133>:
            __cancel_routine (__cancel_arg);
            <D.13134>:
          }
        finally
          {
            __cancel_buf = {CLOBBER};
          }
      }
      D.13112 = ret;
      return D.13112;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


OpenMutex (guint32 access, gboolean inherit, const gunichar2 * name)
{
  _Bool D.13141;
  long int D.13142;
  long int D.13143;
  unsigned int offset.15;
  void * D.13153;
  void * handle;
  gchar * utf8_name;
  int thr_ret;
  void * ret;
  gint32 offset;
  void cleanup = <<< error >>>;
  static const char __func__[10] = "OpenMutex";

  ret = 0B;
  mono_once (&mutex_ops_once, mutex_ops_init);
  thr_ret = _wapi_namespace_lock ();
  D.13141 = thr_ret != 0;
  D.13142 = (long int) D.13141;
  D.13143 = __builtin_expect (D.13142, 0);
  if (D.13143 != 0) goto <D.13144>; else goto <D.13145>;
  <D.13144>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 689, "thr_ret == 0");
  <D.13145>:
  utf8_name = monoeg_g_utf16_to_utf8 (name, -1, 0B, 0B, 0B);
  offset = _wapi_search_handle_namespace (11, utf8_name);
  if (offset == -1) goto <D.13146>; else goto <D.13147>;
  <D.13146>:
  SetLastError (6);
  goto cleanup;
  <D.13147>:
  if (offset == 0) goto <D.13148>; else goto <D.13149>;
  <D.13148>:
  SetLastError (2);
  goto cleanup;
  <D.13149>:
  offset.15 = (unsigned int) offset;
  handle = _wapi_handle_new_from_offset (11, offset.15, 1);
  if (handle == 4294967295B) goto <D.13151>; else goto <D.13152>;
  <D.13151>:
  monoeg_g_log (0B, 16, "%s: error opening named mutex handle", &__func__);
  SetLastError (31);
  goto cleanup;
  <D.13152>:
  ret = handle;
  cleanup:
  monoeg_g_free (utf8_name);
  _wapi_namespace_unlock (0B);
  D.13153 = ret;
  return D.13153;
}