mutex_is_owned (void * handle)
{
  gboolean D.10156;
  struct _WapiHandle_mutex * mutex_handle.0;
  unsigned int D.10159;
  int D.10161;
  int D.10162;
  long unsigned int D.10164;
  long unsigned int D.10165;
  int D.10166;
  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.10154>; else goto <D.10155>;
      <D.10154>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.10156 = 0;
      return D.10156;
      <D.10155>:
      mutex_handle.0 = mutex_handle;
      D.10159 = mutex_handle.0->recursion;
      if (D.10159 != 0) goto <D.10160>; else goto <D.10157>;
      <D.10160>:
      mutex_handle.0 = mutex_handle;
      D.10161 = mutex_handle.0->pid;
      D.10162 = _wapi_getpid ();
      if (D.10161 == D.10162) goto <D.10163>; else goto <D.10157>;
      <D.10163>:
      mutex_handle.0 = mutex_handle;
      D.10164 = mutex_handle.0->tid;
      D.10165 = pthread_self ();
      D.10166 = pthread_equal (D.10164, D.10165);
      if (D.10166 != 0) goto <D.10167>; else goto <D.10157>;
      <D.10167>:
      D.10156 = 1;
      return D.10156;
      <D.10157>:
      D.10156 = 0;
      return D.10156;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


pthread_equal (pthread_t __thread1, pthread_t __thread2)
{
  int D.10170;
  _Bool D.10171;

  D.10171 = __thread1 == __thread2;
  D.10170 = (int) D.10171;
  return D.10170;
}


mutex_own (void * handle)
{
  gboolean D.10175;
  struct _WapiHandle_mutex * mutex_handle.1;
  int D.10177;
  long unsigned int D.10178;
  unsigned int D.10179;
  unsigned int D.10180;
  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.10173>; else goto <D.10174>;
      <D.10173>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.10175 = 0;
      return D.10175;
      <D.10174>:
      _wapi_thread_own_mutex (handle);
      _wapi_handle_set_signal_state (handle, 0, 0);
      mutex_handle.1 = mutex_handle;
      D.10177 = _wapi_getpid ();
      mutex_handle.1->pid = D.10177;
      mutex_handle.1 = mutex_handle;
      D.10178 = pthread_self ();
      mutex_handle.1->tid = D.10178;
      mutex_handle.1 = mutex_handle;
      D.10179 = mutex_handle.1->recursion;
      D.10180 = D.10179 + 1;
      mutex_handle.1->recursion = D.10180;
      D.10175 = 1;
      return D.10175;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


_wapi_handle_set_signal_state (void * handle, gboolean state, gboolean broadcast)
{
  int iftmp.2;
  <unnamed type> D.10189;
  <unnamed type> D.10191;
  <unnamed type> D.10193;
  <unnamed type> D.10195;
  _Bool D.10196;
  long int D.10197;
  long int D.10198;
  unsigned int D.10201;
  struct _WapiHandleUnshared * D.10202;
  unsigned int D.10203;
  unsigned int D.10204;
  long int D.10207;
  union mono_mutex_t * _wapi_global_signal_mutex.3;
  _Bool D.10213;
  long int D.10214;
  long int D.10215;
  union pthread_cond_t * D.10220;
  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.10183>; else goto <D.10184>;
  <D.10183>:
  return;
  <D.10184>:
  D.10189 = _wapi_handle_type (handle);
  if (D.10189 == 9) goto <D.10186>; else goto <D.10190>;
  <D.10190>:
  D.10191 = _wapi_handle_type (handle);
  if (D.10191 == 11) goto <D.10186>; else goto <D.10192>;
  <D.10192>:
  D.10193 = _wapi_handle_type (handle);
  if (D.10193 == 12) goto <D.10186>; else goto <D.10194>;
  <D.10194>:
  D.10195 = _wapi_handle_type (handle);
  if (D.10195 == 13) goto <D.10186>; else goto <D.10187>;
  <D.10186>:
  iftmp.2 = 1;
  goto <D.10188>;
  <D.10187>:
  iftmp.2 = 0;
  <D.10188>:
  D.10196 = iftmp.2 != 0;
  D.10197 = (long int) D.10196;
  D.10198 = __builtin_expect (D.10197, 0);
  if (D.10198 != 0) goto <D.10199>; else goto <D.10200>;
  <D.10199>:
  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.10200>:
  D.10201 = idx / 256;
  D.10202 = _wapi_private_handles[D.10201];
  D.10203 = idx & 255;
  D.10204 = D.10203 * 144;
  handle_data = D.10202 + D.10204;
  if (state == 1) goto <D.10205>; else goto <D.10206>;
  <D.10205>:
  {
    struct __pthread_unwind_buf_t __cancel_buf;
    void (*<Tc3>) (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.10207 = __builtin_expect (__not_first_call, 0);
        if (D.10207 != 0) goto <D.10208>; else goto <D.10209>;
        <D.10208>:
        __cancel_routine (__cancel_arg);
        __pthread_unwind_next (&__cancel_buf);
        <D.10209>:
        __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.10211>; else goto <D.10212>;
        <D.10211>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d for global signal mutex", thr_ret);
        <D.10212>:
        D.10213 = thr_ret != 0;
        D.10214 = (long int) D.10213;
        D.10215 = __builtin_expect (D.10214, 0);
        if (D.10215 != 0) goto <D.10216>; else goto <D.10217>;
        <D.10216>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 151, "thr_ret == 0");
        <D.10217>:
        handle_data->signalled = state;
        if (broadcast == 1) goto <D.10218>; else goto <D.10219>;
        <D.10218>:
        D.10220 = &handle_data->signal_cond;
        thr_ret = pthread_cond_broadcast (D.10220);
        if (thr_ret != 0) goto <D.10221>; else goto <D.10222>;
        <D.10221>:
        monoeg_g_log (0B, 16, "Bad call to pthread_cond_broadcast result %d for handle %p", thr_ret, handle);
        <D.10222>:
        D.10213 = thr_ret != 0;
        D.10214 = (long int) D.10213;
        D.10215 = __builtin_expect (D.10214, 0);
        if (D.10215 != 0) goto <D.10223>; else goto <D.10224>;
        <D.10223>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 162, "thr_ret == 0");
        <D.10224>:
        goto <D.10225>;
        <D.10219>:
        D.10220 = &handle_data->signal_cond;
        thr_ret = pthread_cond_signal (D.10220);
        if (thr_ret != 0) goto <D.10226>; else goto <D.10227>;
        <D.10226>:
        monoeg_g_log (0B, 16, "Bad call to pthread_cond_signal result %d for handle %p", thr_ret, handle);
        <D.10227>:
        D.10213 = thr_ret != 0;
        D.10214 = (long int) D.10213;
        D.10215 = __builtin_expect (D.10214, 0);
        if (D.10215 != 0) goto <D.10228>; else goto <D.10229>;
        <D.10228>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 167, "thr_ret == 0");
        <D.10229>:
        <D.10225>:
        _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.10231>; else goto <D.10232>;
        <D.10231>:
        monoeg_g_log (0B, 16, "Bad call to pthread_cond_broadcast result %d for handle %p", thr_ret, handle);
        <D.10232>:
        D.10213 = thr_ret != 0;
        D.10214 = (long int) D.10213;
        D.10215 = __builtin_expect (D.10214, 0);
        if (D.10215 != 0) goto <D.10233>; else goto <D.10234>;
        <D.10233>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 176, "thr_ret == 0");
        <D.10234>:
        _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.10235>; else goto <D.10236>;
        <D.10235>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d for global signal mutex", thr_ret);
        <D.10236>:
        D.10213 = thr_ret != 0;
        D.10214 = (long int) D.10213;
        D.10215 = __builtin_expect (D.10214, 0);
        if (D.10215 != 0) goto <D.10237>; else goto <D.10238>;
        <D.10237>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 181, "thr_ret == 0");
        <D.10238>:
        __pthread_unregister_cancel (&__cancel_buf);
        if (0 != 0) goto <D.10239>; else goto <D.10240>;
        <D.10239>:
        __cancel_routine (__cancel_arg);
        <D.10240>:
      }
    finally
      {
        __cancel_buf = {CLOBBER};
      }
  }
  goto <D.10241>;
  <D.10206>:
  handle_data->signalled = state;
  <D.10241>:
}


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

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


_wapi_handle_type (void * handle)
{
  unsigned int D.10258;
  struct _WapiHandleUnshared * D.10259;
  WapiHandleType D.10260;
  unsigned int D.10261;
  unsigned int D.10262;
  struct _WapiHandleUnshared * D.10263;
  guint32 idx;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.10254>; else goto <D.10256>;
  <D.10256>:
  if (idx > 268435455) goto <D.10254>; else goto <D.10257>;
  <D.10257>:
  D.10258 = idx / 256;
  D.10259 = _wapi_private_handles[D.10258];
  if (D.10259 == 0B) goto <D.10254>; else goto <D.10255>;
  <D.10254>:
  D.10260 = 0;
  return D.10260;
  <D.10255>:
  D.10258 = idx / 256;
  D.10259 = _wapi_private_handles[D.10258];
  D.10261 = idx & 255;
  D.10262 = D.10261 * 144;
  D.10263 = D.10259 + D.10262;
  D.10260 = D.10263->type;
  return D.10260;
}


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


_wapi_mutex_details (void * handle_info)
{
  int D.10265;
  long unsigned int D.10266;
  unsigned int D.10267;
  struct _WapiHandle_mutex * mut;

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


namedmutex_prewait (void * handle)
{
  struct _WapiHandle_namedmutex * namedmutex_handle.5;
  unsigned int D.10271;
  int D.10275;
  int D.10276;
  unsigned int D.10280;
  _Bool D.10283;
  long int D.10284;
  long int D.10285;
  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.10268>; else goto <D.10269>;
      <D.10268>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      return;
      <D.10269>:
      namedmutex_handle.5 = namedmutex_handle;
      D.10271 = namedmutex_handle.5->recursion;
      if (D.10271 == 0) goto <D.10272>; else goto <D.10273>;
      <D.10272>:
      goto <D.10274>;
      <D.10273>:
      namedmutex_handle.5 = namedmutex_handle;
      D.10275 = namedmutex_handle.5->pid;
      D.10276 = _wapi_getpid ();
      if (D.10275 == D.10276) goto <D.10277>; else goto <D.10278>;
      <D.10277>:
      goto <D.10279>;
      <D.10278>:
      {
        int thr_ret;
        void * proc_handle;

        namedmutex_handle.5 = namedmutex_handle;
        D.10275 = namedmutex_handle.5->pid;
        D.10280 = (unsigned int) D.10275;
        proc_handle = OpenProcess (0, 0, D.10280);
        if (proc_handle == 0B) goto <D.10281>; else goto <D.10282>;
        <D.10281>:
        thr_ret = _wapi_handle_lock_shared_handles ();
        D.10283 = thr_ret != 0;
        D.10284 = (long int) D.10283;
        D.10285 = __builtin_expect (D.10284, 0);
        if (D.10285 != 0) goto <D.10286>; else goto <D.10287>;
        <D.10286>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 274, "thr_ret == 0");
        <D.10287>:
        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.10288>;
        <D.10282>:
        <D.10288>:
        if (proc_handle != 0B) goto <D.10289>; else goto <D.10290>;
        <D.10289>:
        CloseProcess (proc_handle);
        <D.10290>:
      }
      <D.10279>:
      <D.10274>:
    }
  finally
    {
      namedmutex_handle = {CLOBBER};
    }
}


_wapi_handle_lock_shared_handles ()
{
  int D.10294;

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


_wapi_shared_handle_set_signal_state (void * handle, gboolean state)
{
  int iftmp.6;
  <unnamed type> D.10301;
  <unnamed type> D.10303;
  <unnamed type> D.10305;
  <unnamed type> D.10307;
  _Bool D.10309;
  long int D.10310;
  long int D.10311;
  unsigned int D.10314;
  struct _WapiHandleUnshared * D.10315;
  unsigned int D.10316;
  unsigned int D.10317;
  struct _WapiHandleSharedLayout * _wapi_shared_layout.7;
  unsigned int D.10319;
  guint32 idx;
  struct _WapiHandleUnshared * handle_data;
  struct _WapiHandle_shared_ref * ref;
  struct _WapiHandleShared * shared_data;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.10296>; else goto <D.10297>;
  <D.10296>:
  return;
  <D.10297>:
  D.10301 = _wapi_handle_type (handle);
  if (D.10301 != 9) goto <D.10302>; else goto <D.10299>;
  <D.10302>:
  D.10303 = _wapi_handle_type (handle);
  if (D.10303 != 11) goto <D.10304>; else goto <D.10299>;
  <D.10304>:
  D.10305 = _wapi_handle_type (handle);
  if (D.10305 != 12) goto <D.10306>; else goto <D.10299>;
  <D.10306>:
  D.10307 = _wapi_handle_type (handle);
  if (D.10307 != 13) goto <D.10308>; else goto <D.10299>;
  <D.10308>:
  iftmp.6 = 1;
  goto <D.10300>;
  <D.10299>:
  iftmp.6 = 0;
  <D.10300>:
  D.10309 = iftmp.6 != 0;
  D.10310 = (long int) D.10309;
  D.10311 = __builtin_expect (D.10310, 0);
  if (D.10311 != 0) goto <D.10312>; else goto <D.10313>;
  <D.10312>:
  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.10313>:
  D.10314 = idx / 256;
  D.10315 = _wapi_private_handles[D.10314];
  D.10316 = idx & 255;
  D.10317 = D.10316 * 144;
  handle_data = D.10315 + D.10317;
  ref = &handle_data->u.shared;
  _wapi_shared_layout.7 = _wapi_shared_layout;
  D.10319 = ref->offset;
  shared_data = &_wapi_shared_layout.7->handles[D.10319];
  shared_data->signalled = state;
}


_wapi_handle_unlock_shared_handles ()
{
  int D.10321;

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


namedmutex_is_owned (void * handle)
{
  gboolean D.10325;
  struct _WapiHandle_namedmutex * namedmutex_handle.8;
  unsigned int D.10328;
  int D.10330;
  int D.10331;
  long unsigned int D.10333;
  long unsigned int D.10334;
  int D.10335;
  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.10323>; else goto <D.10324>;
      <D.10323>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.10325 = 0;
      return D.10325;
      <D.10324>:
      namedmutex_handle.8 = namedmutex_handle;
      D.10328 = namedmutex_handle.8->recursion;
      if (D.10328 != 0) goto <D.10329>; else goto <D.10326>;
      <D.10329>:
      namedmutex_handle.8 = namedmutex_handle;
      D.10330 = namedmutex_handle.8->pid;
      D.10331 = _wapi_getpid ();
      if (D.10330 == D.10331) goto <D.10332>; else goto <D.10326>;
      <D.10332>:
      namedmutex_handle.8 = namedmutex_handle;
      D.10333 = namedmutex_handle.8->tid;
      D.10334 = pthread_self ();
      D.10335 = pthread_equal (D.10333, D.10334);
      if (D.10335 != 0) goto <D.10336>; else goto <D.10326>;
      <D.10336>:
      D.10325 = 1;
      return D.10325;
      <D.10326>:
      D.10325 = 0;
      return D.10325;
    }
  finally
    {
      namedmutex_handle = {CLOBBER};
    }
}


namedmutex_own (void * handle)
{
  gboolean D.10341;
  struct _WapiHandle_namedmutex * namedmutex_handle.9;
  int D.10343;
  long unsigned int D.10344;
  unsigned int D.10345;
  unsigned int D.10346;
  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.10339>; else goto <D.10340>;
      <D.10339>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      D.10341 = 0;
      return D.10341;
      <D.10340>:
      _wapi_thread_own_mutex (handle);
      namedmutex_handle.9 = namedmutex_handle;
      D.10343 = _wapi_getpid ();
      namedmutex_handle.9->pid = D.10343;
      namedmutex_handle.9 = namedmutex_handle;
      D.10344 = pthread_self ();
      namedmutex_handle.9->tid = D.10344;
      namedmutex_handle.9 = namedmutex_handle;
      D.10345 = namedmutex_handle.9->recursion;
      D.10346 = D.10345 + 1;
      namedmutex_handle.9->recursion = D.10346;
      _wapi_shared_handle_set_signal_state (handle, 0);
      D.10341 = 1;
      return D.10341;
    }
  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.10349>; else goto <D.10350>;
  <D.10349>:
  mutex_abandon (data, pid, tid);
  goto <D.10351>;
  <D.10350>:
  if (type == 11) goto <D.10352>; else goto <D.10353>;
  <D.10352>:
  namedmutex_abandon (data, pid, tid);
  goto <D.10354>;
  <D.10353>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mutexes.c", 369);
  <D.10354>:
  <D.10351>:
}


mutex_abandon (void * handle, pid_t pid, pthread_t tid)
{
  long int D.10357;
  _Bool D.10360;
  long int D.10361;
  long int D.10362;
  struct _WapiHandle_mutex * mutex_handle.10;
  int D.10366;
  long unsigned int D.10369;
  int D.10370;
  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.10355>; else goto <D.10356>;
      <D.10355>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      return;
      <D.10356>:
      {
        struct __pthread_unwind_buf_t __cancel_buf;
        void (*<Tc3>) (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.10357 = __builtin_expect (__not_first_call, 0);
            if (D.10357 != 0) goto <D.10358>; else goto <D.10359>;
            <D.10358>:
            __cancel_routine (__cancel_arg);
            __pthread_unwind_next (&__cancel_buf);
            <D.10359>:
            __pthread_register_cancel (&__cancel_buf);
            thr_ret = _wapi_handle_lock_handle (handle);
            D.10360 = thr_ret != 0;
            D.10361 = (long int) D.10360;
            D.10362 = __builtin_expect (D.10361, 0);
            if (D.10362 != 0) goto <D.10363>; else goto <D.10364>;
            <D.10363>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 307, "thr_ret == 0");
            <D.10364>:
            mutex_handle.10 = mutex_handle;
            D.10366 = mutex_handle.10->pid;
            if (D.10366 == pid) goto <D.10367>; else goto <D.10368>;
            <D.10367>:
            mutex_handle.10 = mutex_handle;
            D.10369 = mutex_handle.10->tid;
            D.10370 = pthread_equal (D.10369, tid);
            if (D.10370 != 0) goto <D.10371>; else goto <D.10372>;
            <D.10371>:
            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.10372>:
            <D.10368>:
            thr_ret = _wapi_handle_unlock_handle (handle);
            D.10360 = thr_ret != 0;
            D.10361 = (long int) D.10360;
            D.10362 = __builtin_expect (D.10361, 0);
            if (D.10362 != 0) goto <D.10373>; else goto <D.10374>;
            <D.10373>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 321, "thr_ret == 0");
            <D.10374>:
            __pthread_unregister_cancel (&__cancel_buf);
            if (0 != 0) goto <D.10375>; else goto <D.10376>;
            <D.10375>:
            __cancel_routine (__cancel_arg);
            <D.10376>:
          }
        finally
          {
            __cancel_buf = {CLOBBER};
          }
      }
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


_wapi_handle_lock_handle (void * handle)
{
  int D.10385;
  <unnamed type> D.10388;
  <unnamed type> D.10390;
  <unnamed type> D.10392;
  <unnamed type> D.10394;
  unsigned int D.10395;
  struct _WapiHandleUnshared * D.10396;
  unsigned int D.10397;
  unsigned int D.10398;
  struct _WapiHandleUnshared * D.10399;
  union mono_mutex_t * D.10400;
  guint32 idx;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.10383>; else goto <D.10384>;
  <D.10383>:
  D.10385 = 0;
  return D.10385;
  <D.10384>:
  _wapi_handle_ref (handle);
  D.10388 = _wapi_handle_type (handle);
  if (D.10388 == 9) goto <D.10386>; else goto <D.10389>;
  <D.10389>:
  D.10390 = _wapi_handle_type (handle);
  if (D.10390 == 11) goto <D.10386>; else goto <D.10391>;
  <D.10391>:
  D.10392 = _wapi_handle_type (handle);
  if (D.10392 == 12) goto <D.10386>; else goto <D.10393>;
  <D.10393>:
  D.10394 = _wapi_handle_type (handle);
  if (D.10394 == 13) goto <D.10386>; else goto <D.10387>;
  <D.10386>:
  D.10385 = 0;
  return D.10385;
  <D.10387>:
  D.10395 = idx / 256;
  D.10396 = _wapi_private_handles[D.10395];
  D.10397 = idx & 255;
  D.10398 = D.10397 * 144;
  D.10399 = D.10396 + D.10398;
  D.10400 = &D.10399->signal_mutex;
  D.10385 = pthread_mutex_lock (D.10400);
  return D.10385;
}


_wapi_handle_unlock_handle (void * handle)
{
  int D.10404;
  <unnamed type> D.10407;
  <unnamed type> D.10409;
  <unnamed type> D.10411;
  <unnamed type> D.10413;
  unsigned int D.10414;
  struct _WapiHandleUnshared * D.10415;
  unsigned int D.10416;
  unsigned int D.10417;
  struct _WapiHandleUnshared * D.10418;
  union mono_mutex_t * D.10419;
  guint32 idx;
  int ret;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.10402>; else goto <D.10403>;
  <D.10402>:
  D.10404 = 0;
  return D.10404;
  <D.10403>:
  D.10407 = _wapi_handle_type (handle);
  if (D.10407 == 9) goto <D.10405>; else goto <D.10408>;
  <D.10408>:
  D.10409 = _wapi_handle_type (handle);
  if (D.10409 == 11) goto <D.10405>; else goto <D.10410>;
  <D.10410>:
  D.10411 = _wapi_handle_type (handle);
  if (D.10411 == 12) goto <D.10405>; else goto <D.10412>;
  <D.10412>:
  D.10413 = _wapi_handle_type (handle);
  if (D.10413 == 13) goto <D.10405>; else goto <D.10406>;
  <D.10405>:
  _wapi_handle_unref (handle);
  D.10404 = 0;
  return D.10404;
  <D.10406>:
  D.10414 = idx / 256;
  D.10415 = _wapi_private_handles[D.10414];
  D.10416 = idx & 255;
  D.10417 = D.10416 * 144;
  D.10418 = D.10415 + D.10417;
  D.10419 = &D.10418->signal_mutex;
  ret = pthread_mutex_unlock (D.10419);
  _wapi_handle_unref (handle);
  D.10404 = ret;
  return D.10404;
}


namedmutex_abandon (void * handle, pid_t pid, pthread_t tid)
{
  _Bool D.10423;
  long int D.10424;
  long int D.10425;
  struct _WapiHandle_namedmutex * mutex_handle.11;
  int D.10429;
  long unsigned int D.10432;
  int D.10433;
  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.10421>; else goto <D.10422>;
      <D.10421>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      return;
      <D.10422>:
      thr_ret = _wapi_handle_lock_shared_handles ();
      D.10423 = thr_ret != 0;
      D.10424 = (long int) D.10423;
      D.10425 = __builtin_expect (D.10424, 0);
      if (D.10425 != 0) goto <D.10426>; else goto <D.10427>;
      <D.10426>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 340, "thr_ret == 0");
      <D.10427>:
      mutex_handle.11 = mutex_handle;
      D.10429 = mutex_handle.11->pid;
      if (D.10429 == pid) goto <D.10430>; else goto <D.10431>;
      <D.10430>:
      mutex_handle.11 = mutex_handle;
      D.10432 = mutex_handle.11->tid;
      D.10433 = pthread_equal (D.10432, tid);
      if (D.10433 != 0) goto <D.10434>; else goto <D.10435>;
      <D.10434>:
      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.10435>:
      <D.10431>:
      _wapi_handle_unlock_shared_handles ();
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


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

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


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


mutex_create (struct WapiSecurityAttributes * security, gboolean owned)
{
  void * D.10445;
  long int D.10446;
  _Bool D.10449;
  long int D.10450;
  long int D.10451;
  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.10443>; else goto <D.10444>;
      <D.10443>:
      monoeg_g_log (0B, 16, "%s: error creating mutex handle", &__func__);
      SetLastError (31);
      D.10445 = 0B;
      return D.10445;
      <D.10444>:
      {
        struct __pthread_unwind_buf_t __cancel_buf;
        void (*<Tc3>) (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.10446 = __builtin_expect (__not_first_call, 0);
            if (D.10446 != 0) goto <D.10447>; else goto <D.10448>;
            <D.10447>:
            __cancel_routine (__cancel_arg);
            __pthread_unwind_next (&__cancel_buf);
            <D.10448>:
            __pthread_register_cancel (&__cancel_buf);
            thr_ret = _wapi_handle_lock_handle (handle);
            D.10449 = thr_ret != 0;
            D.10450 = (long int) D.10449;
            D.10451 = __builtin_expect (D.10450, 0);
            if (D.10451 != 0) goto <D.10452>; else goto <D.10453>;
            <D.10452>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 398, "thr_ret == 0");
            <D.10453>:
            if (owned == 1) goto <D.10454>; else goto <D.10455>;
            <D.10454>:
            mutex_own (handle);
            goto <D.10456>;
            <D.10455>:
            _wapi_handle_set_signal_state (handle, 1, 0);
            <D.10456>:
            thr_ret = _wapi_handle_unlock_handle (handle);
            D.10449 = thr_ret != 0;
            D.10450 = (long int) D.10449;
            D.10451 = __builtin_expect (D.10450, 0);
            if (D.10451 != 0) goto <D.10457>; else goto <D.10458>;
            <D.10457>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 409, "thr_ret == 0");
            <D.10458>:
            __pthread_unregister_cancel (&__cancel_buf);
            if (0 != 0) goto <D.10459>; else goto <D.10460>;
            <D.10459>:
            __cancel_routine (__cancel_arg);
            <D.10460>:
          }
        finally
          {
            __cancel_buf = {CLOBBER};
          }
      }
      D.10445 = handle;
      return D.10445;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


namedmutex_create (struct WapiSecurityAttributes * security, gboolean owned, const gunichar2 * name)
{
  _Bool D.10466;
  long int D.10467;
  long int D.10468;
  unsigned int D.10477;
  unsigned int offset.12;
  void * D.10492;
  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.10466 = thr_ret != 0;
      D.10467 = (long int) D.10466;
      D.10468 = __builtin_expect (D.10467, 0);
      if (D.10468 != 0) goto <D.10469>; else goto <D.10470>;
      <D.10469>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 430, "thr_ret == 0");
      <D.10470>:
      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.10471>; else goto <D.10472>;
      <D.10471>:
      SetLastError (6);
      goto cleanup;
      <D.10472>:
      if (offset != 0) goto <D.10473>; else goto <D.10474>;
      <D.10473>:
      SetLastError (183);
      <D.10474>:
      if (offset == 0) goto <D.10475>; else goto <D.10476>;
      <D.10475>:
      D.10477 = strlen (utf8_name);
      if (D.10477 <= 259) goto <D.10478>; else goto <D.10479>;
      <D.10478>:
      namelen = strlen (utf8_name);
      goto <D.10480>;
      <D.10479>:
      namelen = 260;
      <D.10480>:
      memcpy (&namedmutex_handle.sharedns.name, utf8_name, namelen);
      handle = _wapi_handle_new (11, &namedmutex_handle);
      goto <D.10481>;
      <D.10476>:
      offset.12 = (unsigned int) offset;
      handle = _wapi_handle_new_from_offset (11, offset.12, 1);
      <D.10481>:
      if (handle == 4294967295B) goto <D.10483>; else goto <D.10484>;
      <D.10483>:
      monoeg_g_log (0B, 16, "%s: error creating mutex handle", &__func__);
      SetLastError (31);
      goto cleanup;
      <D.10484>:
      ret = handle;
      if (offset == 0) goto <D.10485>; else goto <D.10486>;
      <D.10485>:
      thr_ret = _wapi_handle_lock_shared_handles ();
      D.10466 = thr_ret != 0;
      D.10467 = (long int) D.10466;
      D.10468 = __builtin_expect (D.10467, 0);
      if (D.10468 != 0) goto <D.10487>; else goto <D.10488>;
      <D.10487>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 493, "thr_ret == 0");
      <D.10488>:
      if (owned == 1) goto <D.10489>; else goto <D.10490>;
      <D.10489>:
      namedmutex_own (handle);
      goto <D.10491>;
      <D.10490>:
      _wapi_shared_handle_set_signal_state (handle, 1);
      <D.10491>:
      _wapi_handle_unlock_shared_handles ();
      <D.10486>:
      cleanup:
      monoeg_g_free (utf8_name);
      _wapi_namespace_unlock (0B);
      D.10492 = ret;
      return D.10492;
    }
  finally
    {
      namedmutex_handle = {CLOBBER};
    }
}


_wapi_namespace_lock ()
{
  int D.10495;

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


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

  D.10498 = __builtin_object_size (__dest, 0);
  D.10497 = __builtin___memcpy_chk (__dest, __src, __len, D.10498);
  return D.10497;
}


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

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


ReleaseMutex (void * handle)
{
  gboolean D.10504;
  gboolean (*<T1569>) (void *) D.10505;
  WapiHandleType type;

  if (handle == 0B) goto <D.10502>; else goto <D.10503>;
  <D.10502>:
  SetLastError (6);
  D.10504 = 0;
  return D.10504;
  <D.10503>:
  type = _wapi_handle_type (handle);
  D.10505 = mutex_ops[type].release;
  if (D.10505 == 0B) goto <D.10506>; else goto <D.10507>;
  <D.10506>:
  SetLastError (6);
  D.10504 = 0;
  return D.10504;
  <D.10507>:
  D.10505 = mutex_ops[type].release;
  D.10504 = D.10505 (handle);
  return D.10504;
}


namedmutex_release (void * handle)
{
  gboolean D.10511;
  _Bool D.10512;
  long int D.10513;
  long int D.10514;
  struct _WapiHandle_namedmutex * mutex_handle.13;
  long unsigned int D.10518;
  int D.10519;
  int D.10521;
  unsigned int D.10523;
  unsigned int D.10524;
  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.10509>; else goto <D.10510>;
      <D.10509>:
      monoeg_g_log (0B, 16, "%s: error looking up named mutex handle %p", &__func__, handle);
      D.10511 = 0;
      return D.10511;
      <D.10510>:
      thr_ret = _wapi_handle_lock_shared_handles ();
      D.10512 = thr_ret != 0;
      D.10513 = (long int) D.10512;
      D.10514 = __builtin_expect (D.10513, 0);
      if (D.10514 != 0) goto <D.10515>; else goto <D.10516>;
      <D.10515>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 616, "thr_ret == 0");
      <D.10516>:
      mutex_handle.13 = mutex_handle;
      D.10518 = mutex_handle.13->tid;
      D.10519 = pthread_equal (D.10518, tid);
      if (D.10519 == 0) goto cleanup; else goto <D.10520>;
      <D.10520>:
      mutex_handle.13 = mutex_handle;
      D.10521 = mutex_handle.13->pid;
      if (D.10521 != pid) goto cleanup; else goto <D.10522>;
      <D.10522>:
      ret = 1;
      mutex_handle.13 = mutex_handle;
      D.10523 = mutex_handle.13->recursion;
      D.10524 = D.10523 + 4294967295;
      mutex_handle.13->recursion = D.10524;
      mutex_handle.13 = mutex_handle;
      D.10523 = mutex_handle.13->recursion;
      if (D.10523 == 0) goto <D.10525>; else goto <D.10526>;
      <D.10525>:
      _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.10526>:
      cleanup:
      _wapi_handle_unlock_shared_handles ();
      D.10511 = ret;
      return D.10511;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


mutex_release (void * handle)
{
  gboolean D.10531;
  long int D.10532;
  _Bool D.10535;
  long int D.10536;
  long int D.10537;
  struct _WapiHandle_mutex * mutex_handle.14;
  long unsigned int D.10541;
  int D.10542;
  int D.10544;
  unsigned int D.10546;
  unsigned int D.10547;
  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.10529>; else goto <D.10530>;
      <D.10529>:
      monoeg_g_log (0B, 16, "%s: error looking up mutex handle %p", &__func__, handle);
      D.10531 = 0;
      return D.10531;
      <D.10530>:
      {
        struct __pthread_unwind_buf_t __cancel_buf;
        void (*<Tc3>) (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.10532 = __builtin_expect (__not_first_call, 0);
            if (D.10532 != 0) goto <D.10533>; else goto <D.10534>;
            <D.10533>:
            __cancel_routine (__cancel_arg);
            __pthread_unwind_next (&__cancel_buf);
            <D.10534>:
            __pthread_register_cancel (&__cancel_buf);
            thr_ret = _wapi_handle_lock_handle (handle);
            D.10535 = thr_ret != 0;
            D.10536 = (long int) D.10535;
            D.10537 = __builtin_expect (D.10536, 0);
            if (D.10537 != 0) goto <D.10538>; else goto <D.10539>;
            <D.10538>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 565, "thr_ret == 0");
            <D.10539>:
            mutex_handle.14 = mutex_handle;
            D.10541 = mutex_handle.14->tid;
            D.10542 = pthread_equal (D.10541, tid);
            if (D.10542 == 0) goto cleanup; else goto <D.10543>;
            <D.10543>:
            mutex_handle.14 = mutex_handle;
            D.10544 = mutex_handle.14->pid;
            if (D.10544 != pid) goto cleanup; else goto <D.10545>;
            <D.10545>:
            ret = 1;
            mutex_handle.14 = mutex_handle;
            D.10546 = mutex_handle.14->recursion;
            D.10547 = D.10546 + 4294967295;
            mutex_handle.14->recursion = D.10547;
            mutex_handle.14 = mutex_handle;
            D.10546 = mutex_handle.14->recursion;
            if (D.10546 == 0) goto <D.10548>; else goto <D.10549>;
            <D.10548>:
            _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.10549>:
            cleanup:
            thr_ret = _wapi_handle_unlock_handle (handle);
            D.10535 = thr_ret != 0;
            D.10536 = (long int) D.10535;
            D.10537 = __builtin_expect (D.10536, 0);
            if (D.10537 != 0) goto <D.10550>; else goto <D.10551>;
            <D.10550>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 592, "thr_ret == 0");
            <D.10551>:
            __pthread_unregister_cancel (&__cancel_buf);
            if (0 != 0) goto <D.10552>; else goto <D.10553>;
            <D.10552>:
            __cancel_routine (__cancel_arg);
            <D.10553>:
          }
        finally
          {
            __cancel_buf = {CLOBBER};
          }
      }
      D.10531 = ret;
      return D.10531;
    }
  finally
    {
      mutex_handle = {CLOBBER};
    }
}


OpenMutex (guint32 access, gboolean inherit, const gunichar2 * name)
{
  _Bool D.10560;
  long int D.10561;
  long int D.10562;
  unsigned int offset.15;
  void * D.10572;
  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.10560 = thr_ret != 0;
  D.10561 = (long int) D.10560;
  D.10562 = __builtin_expect (D.10561, 0);
  if (D.10562 != 0) goto <D.10563>; else goto <D.10564>;
  <D.10563>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mutexes.c", 689, "thr_ret == 0");
  <D.10564>:
  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.10565>; else goto <D.10566>;
  <D.10565>:
  SetLastError (6);
  goto cleanup;
  <D.10566>:
  if (offset == 0) goto <D.10567>; else goto <D.10568>;
  <D.10567>:
  SetLastError (2);
  goto cleanup;
  <D.10568>:
  offset.15 = (unsigned int) offset;
  handle = _wapi_handle_new_from_offset (11, offset.15, 1);
  if (handle == 4294967295B) goto <D.10570>; else goto <D.10571>;
  <D.10570>:
  monoeg_g_log (0B, 16, "%s: error opening named mutex handle", &__func__);
  SetLastError (31);
  goto cleanup;
  <D.10571>:
  ret = handle;
  cleanup:
  monoeg_g_free (utf8_name);
  _wapi_namespace_unlock (0B);
  D.10572 = ret;
  return D.10572;
}