__attribute__((visibility ("hidden")))
mono_thread_small_id_alloc ()
{
  _Bool D.14729;
  long int D.14730;
  long int D.14731;
  struct MonoBitSet * small_id_table.0;
  struct MonoBitSet * D.14737;
  int small_id_next.1;
  long unsigned int D.14743;
  long unsigned int D.14744;
  unsigned int D.14747;
  unsigned int D.14748;
  unsigned int D.14749;
  unsigned int D.14750;
  int D.14751;
  long unsigned int D.14752;
  long unsigned int D.14753;
  long unsigned int D.14754;
  unsigned int id.2;
  unsigned int D.14756;
  long unsigned int D.14757;
  long unsigned int D.14758;
  _Bool D.14759;
  long int D.14760;
  long int D.14761;
  long unsigned int D.14764;
  long unsigned int D.14765;
  long unsigned int D.14766;
  long unsigned int D.14767;
  int D.14768;
  long unsigned int D.14769;
  _Bool D.14772;
  long int D.14773;
  long int D.14774;
  int hazard_table_size.3;
  int hazard_table_size.4;
  long unsigned int D.14781;
  long unsigned int D.14782;
  long unsigned int D.14783;
  long unsigned int D.14784;
  long unsigned int D.14785;
  long unsigned int D.14786;
  struct MonoThreadHazardPointers * hazard_table.5;
  void * D.14790;
  struct MonoThreadHazardPointers * hazard_table.6;
  _Bool D.14792;
  long int D.14793;
  long int D.14794;
  struct MonoThreadHazardPointers * hazard_table.7;
  int D.14798;
  sizetype D.14799;
  long unsigned int D.14800;
  long unsigned int D.14801;
  long unsigned int D.14802;
  int D.14803;
  int hazard_table_size.8;
  _Bool D.14805;
  long int D.14806;
  long int D.14807;
  struct MonoThreadHazardPointers * hazard_table.9;
  long unsigned int D.14811;
  struct MonoThreadHazardPointers * D.14812;
  int highest_small_id.10;
  _Bool D.14818;
  long int D.14819;
  long int D.14820;
  int D.14823;
  int i;
  int id;

  id = -1;
  {
    int ret;

    ret = pthread_mutex_lock (&small_id_mutex.mutex);
    if (ret != 0) goto <D.14727>; else goto <D.14728>;
    <D.14727>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14728>:
    D.14729 = ret != 0;
    D.14730 = (long int) D.14729;
    D.14731 = __builtin_expect (D.14730, 0);
    if (D.14731 != 0) goto <D.14732>; else goto <D.14733>;
    <D.14732>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 56, "ret == 0");
    <D.14733>:
  }
  small_id_table.0 = small_id_table;
  if (small_id_table.0 == 0B) goto <D.14735>; else goto <D.14736>;
  <D.14735>:
  D.14737 = mono_bitset_new (1, 0);
  small_id_table = D.14737;
  <D.14736>:
  small_id_table.0 = small_id_table;
  small_id_next.1 = small_id_next;
  id = mono_bitset_find_first_unset (small_id_table.0, small_id_next.1);
  if (id == -1) goto <D.14739>; else goto <D.14740>;
  <D.14739>:
  small_id_table.0 = small_id_table;
  id = mono_bitset_find_first_unset (small_id_table.0, -1);
  <D.14740>:
  if (id == -1) goto <D.14741>; else goto <D.14742>;
  <D.14741>:
  {
    struct MonoBitSet * new_table;

    small_id_table.0 = small_id_table;
    D.14743 = small_id_table.0->size;
    D.14744 = D.14743 * 2;
    if (D.14744 > 65535) goto <D.14745>; else goto <D.14746>;
    <D.14745>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "hazard-pointer.c", 68);
    <D.14746>:
    small_id_table.0 = small_id_table;
    small_id_table.0 = small_id_table;
    D.14743 = small_id_table.0->size;
    D.14747 = (unsigned int) D.14743;
    D.14748 = D.14747 * 2;
    new_table = mono_bitset_clone (small_id_table.0, D.14748);
    small_id_table.0 = small_id_table;
    D.14743 = small_id_table.0->size;
    D.14749 = (unsigned int) D.14743;
    D.14750 = D.14749 + 4294967295;
    D.14751 = (int) D.14750;
    id = mono_bitset_find_first_unset (new_table, D.14751);
    small_id_table.0 = small_id_table;
    mono_bitset_free (small_id_table.0);
    small_id_table = new_table;
  }
  <D.14742>:
  small_id_table.0 = small_id_table;
  D.14752 = (long unsigned int) id;
  D.14753 = D.14752 / 64;
  D.14754 = small_id_table.0->data[D.14753];
  id.2 = (unsigned int) id;
  D.14756 = id.2 & 63;
  D.14757 = D.14754 >> D.14756;
  D.14758 = D.14757 & 1;
  D.14759 = D.14758 != 0;
  D.14760 = (long int) D.14759;
  D.14761 = __builtin_expect (D.14760, 0);
  if (D.14761 != 0) goto <D.14762>; else goto <D.14763>;
  <D.14762>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 76, "!mono_bitset_test_fast (small_id_table, id)");
  <D.14763>:
  small_id_table.0 = small_id_table;
  D.14752 = (long unsigned int) id;
  D.14764 = D.14752 / 64;
  small_id_table.0 = small_id_table;
  D.14765 = small_id_table.0->data[D.14764];
  id.2 = (unsigned int) id;
  D.14756 = id.2 & 63;
  D.14766 = 1 << D.14756;
  D.14767 = D.14765 | D.14766;
  small_id_table.0->data[D.14764] = D.14767;
  small_id_next.1 = small_id_next;
  D.14768 = small_id_next.1 + 1;
  small_id_next = D.14768;
  small_id_next.1 = small_id_next;
  D.14769 = (long unsigned int) small_id_next.1;
  small_id_table.0 = small_id_table;
  D.14743 = small_id_table.0->size;
  if (D.14769 >= D.14743) goto <D.14770>; else goto <D.14771>;
  <D.14770>:
  small_id_next = 0;
  <D.14771>:
  D.14772 = id > 16383;
  D.14773 = (long int) D.14772;
  D.14774 = __builtin_expect (D.14773, 0);
  if (D.14774 != 0) goto <D.14775>; else goto <D.14776>;
  <D.14775>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 83, "id < HAZARD_TABLE_MAX_SIZE");
  <D.14776>:
  hazard_table_size.3 = hazard_table_size;
  if (id >= hazard_table_size.3) goto <D.14778>; else goto <D.14779>;
  <D.14778>:
  {
    void * page_addr;
    int pagesize;
    int num_pages;

    pagesize = mono_pagesize ();
    hazard_table_size.4 = hazard_table_size;
    D.14781 = (long unsigned int) hazard_table_size.4;
    D.14782 = D.14781 * 24;
    D.14783 = (long unsigned int) pagesize;
    D.14784 = D.14782 + D.14783;
    D.14785 = D.14784 + 18446744073709551615;
    D.14783 = (long unsigned int) pagesize;
    D.14786 = D.14785 / D.14783;
    num_pages = (int) D.14786;
    hazard_table.5 = hazard_table;
    if (hazard_table.5 == 0B) goto <D.14788>; else goto <D.14789>;
    <D.14788>:
    D.14790 = mono_valloc (0B, 393216, 0);
    hazard_table = D.14790;
    <D.14789>:
    hazard_table.6 = hazard_table;
    D.14792 = hazard_table.6 == 0B;
    D.14793 = (long int) D.14792;
    D.14794 = __builtin_expect (D.14793, 0);
    if (D.14794 != 0) goto <D.14795>; else goto <D.14796>;
    <D.14795>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 99, "hazard_table != NULL");
    <D.14796>:
    hazard_table.7 = hazard_table;
    D.14798 = num_pages * pagesize;
    D.14799 = (sizetype) D.14798;
    page_addr = hazard_table.7 + D.14799;
    D.14800 = (long unsigned int) pagesize;
    mono_mprotect (page_addr, D.14800, 3);
    num_pages = num_pages + 1;
    D.14798 = num_pages * pagesize;
    D.14801 = (long unsigned int) D.14798;
    D.14802 = D.14801 / 24;
    D.14803 = (int) D.14802;
    hazard_table_size = D.14803;
    hazard_table_size.8 = hazard_table_size;
    D.14805 = id >= hazard_table_size.8;
    D.14806 = (long int) D.14805;
    D.14807 = __builtin_expect (D.14806, 0);
    if (D.14807 != 0) goto <D.14808>; else goto <D.14809>;
    <D.14808>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 108, "id < hazard_table_size");
    <D.14809>:
    i = 0;
    goto <D.14657>;
    <D.14656>:
    hazard_table.9 = hazard_table;
    D.14752 = (long unsigned int) id;
    D.14811 = D.14752 * 24;
    D.14812 = hazard_table.9 + D.14811;
    D.14812->hazard_pointers[i] = 0B;
    i = i + 1;
    <D.14657>:
    if (i <= 2) goto <D.14656>; else goto <D.14658>;
    <D.14658>:
  }
  <D.14779>:
  highest_small_id.10 = highest_small_id;
  if (id > highest_small_id.10) goto <D.14814>; else goto <D.14815>;
  <D.14814>:
  highest_small_id = id;
  mono_memory_write_barrier ();
  <D.14815>:
  {
    int ret;

    ret = pthread_mutex_unlock (&small_id_mutex.mutex);
    if (ret != 0) goto <D.14816>; else goto <D.14817>;
    <D.14816>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14817>:
    D.14818 = ret != 0;
    D.14819 = (long int) D.14818;
    D.14820 = __builtin_expect (D.14819, 0);
    if (D.14820 != 0) goto <D.14821>; else goto <D.14822>;
    <D.14821>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 118, "ret == 0");
    <D.14822>:
  }
  D.14823 = id;
  return D.14823;
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


__attribute__((visibility ("hidden")))
mono_thread_small_id_free (int id)
{
  _Bool D.14827;
  long int D.14828;
  long int D.14829;
  int iftmp.11;
  long unsigned int D.14837;
  struct MonoBitSet * small_id_table.12;
  long unsigned int D.14839;
  _Bool D.14840;
  long int D.14841;
  long int D.14842;
  long unsigned int D.14845;
  long unsigned int D.14846;
  long unsigned int D.14847;
  unsigned int id.13;
  unsigned int D.14849;
  long unsigned int D.14850;
  long unsigned int D.14851;
  _Bool D.14852;
  long int D.14853;
  long int D.14854;
  long unsigned int D.14857;
  long unsigned int D.14858;
  long unsigned int D.14859;
  long unsigned int D.14860;
  long unsigned int D.14861;
  _Bool D.14864;
  long int D.14865;
  long int D.14866;

  {
    int ret;

    ret = pthread_mutex_lock (&small_id_mutex.mutex);
    if (ret != 0) goto <D.14825>; else goto <D.14826>;
    <D.14825>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14826>:
    D.14827 = ret != 0;
    D.14828 = (long int) D.14827;
    D.14829 = __builtin_expect (D.14828, 0);
    if (D.14829 != 0) goto <D.14830>; else goto <D.14831>;
    <D.14830>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 127, "ret == 0");
    <D.14831>:
  }
  if (id < 0) goto <D.14833>; else goto <D.14836>;
  <D.14836>:
  D.14837 = (long unsigned int) id;
  small_id_table.12 = small_id_table;
  D.14839 = small_id_table.12->size;
  if (D.14837 >= D.14839) goto <D.14833>; else goto <D.14834>;
  <D.14833>:
  iftmp.11 = 1;
  goto <D.14835>;
  <D.14834>:
  iftmp.11 = 0;
  <D.14835>:
  D.14840 = iftmp.11 != 0;
  D.14841 = (long int) D.14840;
  D.14842 = __builtin_expect (D.14841, 0);
  if (D.14842 != 0) goto <D.14843>; else goto <D.14844>;
  <D.14843>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 129, "id >= 0 && id < small_id_table->size");
  <D.14844>:
  small_id_table.12 = small_id_table;
  D.14845 = (long unsigned int) id;
  D.14846 = D.14845 / 64;
  D.14847 = small_id_table.12->data[D.14846];
  id.13 = (unsigned int) id;
  D.14849 = id.13 & 63;
  D.14850 = D.14847 >> D.14849;
  D.14851 = D.14850 & 1;
  D.14852 = D.14851 == 0;
  D.14853 = (long int) D.14852;
  D.14854 = __builtin_expect (D.14853, 0);
  if (D.14854 != 0) goto <D.14855>; else goto <D.14856>;
  <D.14855>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 130, "mono_bitset_test_fast (small_id_table, id)");
  <D.14856>:
  small_id_table.12 = small_id_table;
  D.14845 = (long unsigned int) id;
  D.14857 = D.14845 / 64;
  small_id_table.12 = small_id_table;
  D.14858 = small_id_table.12->data[D.14857];
  id.13 = (unsigned int) id;
  D.14849 = id.13 & 63;
  D.14859 = 1 << D.14849;
  D.14860 = ~D.14859;
  D.14861 = D.14858 & D.14860;
  small_id_table.12->data[D.14857] = D.14861;
  {
    int ret;

    ret = pthread_mutex_unlock (&small_id_mutex.mutex);
    if (ret != 0) goto <D.14862>; else goto <D.14863>;
    <D.14862>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14863>:
    D.14864 = ret != 0;
    D.14865 = (long int) D.14864;
    D.14866 = __builtin_expect (D.14865, 0);
    if (D.14866 != 0) goto <D.14867>; else goto <D.14868>;
    <D.14867>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 133, "ret == 0");
    <D.14868>:
  }
}


__attribute__((visibility ("hidden")))
mono_hazard_pointer_get ()
{
  long unsigned int D.14871;
  void * D.14872;
  struct MonoThreadHazardPointers * D.14873;
  struct MonoThreadHazardPointers * hazard_table.14;
  long unsigned int D.14875;
  long unsigned int D.14876;
  int small_id;

  small_id = mono_thread_info_get_small_id ();
  if (small_id < 0) goto <D.14869>; else goto <D.14870>;
  <D.14869>:
  {
    static struct MonoThreadHazardPointers emerg_hazard_table;

    D.14871 = mono_native_thread_id_get ();
    D.14872 = (void *) D.14871;
    monoeg_g_log (0B, 16, "Thread %p may have been prematurely finalized", D.14872);
    D.14873 = &emerg_hazard_table;
    return D.14873;
  }
  <D.14870>:
  hazard_table.14 = hazard_table;
  D.14875 = (long unsigned int) small_id;
  D.14876 = D.14875 * 24;
  D.14873 = hazard_table.14 + D.14876;
  return D.14873;
}


__attribute__((visibility ("hidden")))
get_hazardous_pointer (void * volatile * pp, struct MonoThreadHazardPointers * hp, int hazard_index)
{
  void * D.14880;
  unsigned int hazard_index.15;
  _Bool D.14882;
  long int D.14883;
  long int D.14884;
  void * D.14887;
  void * p;

  <D.14690>:
  p = *pp;
  if (hp == 0B) goto <D.14878>; else goto <D.14879>;
  <D.14878>:
  D.14880 = p;
  return D.14880;
  <D.14879>:
  hazard_index.15 = (unsigned int) hazard_index;
  D.14882 = hazard_index.15 > 2;
  D.14883 = (long int) D.14882;
  D.14884 = __builtin_expect (D.14883, 0);
  if (D.14884 != 0) goto <D.14885>; else goto <D.14886>;
  <D.14885>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 186, "(hazard_index) >= 0 && (hazard_index) < HAZARD_POINTER_COUNT");
  <D.14886>:
  hp->hazard_pointers[hazard_index] = p;
  mono_memory_write_barrier ();
  D.14887 = *pp;
  if (D.14887 != p) goto <D.14888>; else goto <D.14889>;
  <D.14888>:
  hazard_index.15 = (unsigned int) hazard_index;
  D.14882 = hazard_index.15 > 2;
  D.14883 = (long int) D.14882;
  D.14884 = __builtin_expect (D.14883, 0);
  if (D.14884 != 0) goto <D.14890>; else goto <D.14891>;
  <D.14890>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 190, "(hazard_index) >= 0 && (hazard_index) < HAZARD_POINTER_COUNT");
  <D.14891>:
  hp->hazard_pointers[hazard_index] = 0B;
  // predicted unlikely by continue predictor.
  goto <D.14688>;
  <D.14889>:
  goto <D.14689>;
  <D.14688>:
  goto <D.14690>;
  <D.14689>:
  D.14880 = p;
  return D.14880;
}


__attribute__((visibility ("hidden")))
mono_thread_hazardous_free_or_queue (void * p, void (*MonoHazardousFreeFunc) (void *) free_func, gboolean free_func_might_lock, gboolean lock_free_context)
{
  _Bool D.14895;
  long int D.14896;
  long int D.14897;
  _Bool D.14902;
  long int D.14903;
  long int D.14904;
  int D.14907;
  long unsigned int D.14910;
  long unsigned int D.14911;
  int i;

  if (lock_free_context != 0) goto <D.14893>; else goto <D.14894>;
  <D.14893>:
  D.14895 = free_func_might_lock != 0;
  D.14896 = (long int) D.14895;
  D.14897 = __builtin_expect (D.14896, 0);
  if (D.14897 != 0) goto <D.14898>; else goto <D.14899>;
  <D.14898>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 225, "!free_func_might_lock");
  <D.14899>:
  <D.14894>:
  if (free_func_might_lock != 0) goto <D.14900>; else goto <D.14901>;
  <D.14900>:
  D.14902 = lock_free_context != 0;
  D.14903 = (long int) D.14902;
  D.14904 = __builtin_expect (D.14903, 0);
  if (D.14904 != 0) goto <D.14905>; else goto <D.14906>;
  <D.14905>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 227, "!lock_free_context");
  <D.14906>:
  <D.14901>:
  i = 0;
  goto <D.14704>;
  <D.14703>:
  try_free_delayed_free_item (lock_free_context);
  i = i + 1;
  <D.14704>:
  if (i <= 2) goto <D.14703>; else goto <D.14705>;
  <D.14705>:
  D.14907 = is_pointer_hazardous (p);
  if (D.14907 != 0) goto <D.14908>; else goto <D.14909>;
  <D.14908>:
  {
    struct DelayedFreeItem item;

    try
      {
        item.p = p;
        item.free_func = free_func;
        item.might_lock = free_func_might_lock;
        D.14910 = mono_stats.hazardous_pointer_count;
        D.14911 = D.14910 + 1;
        mono_stats.hazardous_pointer_count = D.14911;
        mono_lock_free_array_queue_push (&delayed_free_queue, &item);
      }
    finally
      {
        item = {CLOBBER};
      }
  }
  goto <D.14912>;
  <D.14909>:
  free_func (p);
  <D.14912>:
}


try_free_delayed_free_item (gboolean lock_free_context)
{
  gboolean D.14915;
  int D.14920;
  void * D.14921;
  int D.14922;
  void (*<T11c0>) (void *) D.14923;
  struct DelayedFreeItem item;
  gboolean popped;

  try
    {
      popped = mono_lock_free_array_queue_pop (&delayed_free_queue, &item);
      if (popped == 0) goto <D.14913>; else goto <D.14914>;
      <D.14913>:
      D.14915 = 0;
      return D.14915;
      <D.14914>:
      if (lock_free_context != 0) goto <D.14919>; else goto <D.14916>;
      <D.14919>:
      D.14920 = item.might_lock;
      if (D.14920 != 0) goto <D.14917>; else goto <D.14916>;
      <D.14916>:
      D.14921 = item.p;
      D.14922 = is_pointer_hazardous (D.14921);
      if (D.14922 != 0) goto <D.14917>; else goto <D.14918>;
      <D.14917>:
      mono_lock_free_array_queue_push (&delayed_free_queue, &item);
      D.14915 = 0;
      return D.14915;
      <D.14918>:
      D.14923 = item.free_func;
      D.14921 = item.p;
      D.14923 (D.14921);
      D.14915 = 1;
      return D.14915;
    }
  finally
    {
      item = {CLOBBER};
    }
}


is_pointer_hazardous (void * p)
{
  int hazard_table_size.16;
  _Bool D.14927;
  long int D.14928;
  long int D.14929;
  struct MonoThreadHazardPointers * hazard_table.17;
  long unsigned int D.14933;
  long unsigned int D.14934;
  struct MonoThreadHazardPointers * D.14935;
  void * D.14936;
  gboolean D.14939;
  int i;
  int j;
  int highest;

  highest = highest_small_id;
  hazard_table_size.16 = hazard_table_size;
  D.14927 = highest >= hazard_table_size.16;
  D.14928 = (long int) D.14927;
  D.14929 = __builtin_expect (D.14928, 0);
  if (D.14929 != 0) goto <D.14930>; else goto <D.14931>;
  <D.14930>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "hazard-pointer.c", 142, "highest < hazard_table_size");
  <D.14931>:
  i = 0;
  goto <D.14675>;
  <D.14674>:
  j = 0;
  goto <D.14672>;
  <D.14671>:
  hazard_table.17 = hazard_table;
  D.14933 = (long unsigned int) i;
  D.14934 = D.14933 * 24;
  D.14935 = hazard_table.17 + D.14934;
  D.14936 = D.14935->hazard_pointers[j];
  if (D.14936 == p) goto <D.14937>; else goto <D.14938>;
  <D.14937>:
  D.14939 = 1;
  return D.14939;
  <D.14938>:
  j = j + 1;
  <D.14672>:
  if (j <= 2) goto <D.14671>; else goto <D.14673>;
  <D.14673>:
  i = i + 1;
  <D.14675>:
  if (i <= highest) goto <D.14674>; else goto <D.14676>;
  <D.14676>:
  D.14939 = 0;
  return D.14939;
}


__attribute__((visibility ("hidden")))
mono_thread_hazardous_try_free_all ()
{
  int D.14941;

  goto <D.14711>;
  <D.14710>:
  <D.14711>:
  D.14941 = try_free_delayed_free_item (0);
  if (D.14941 != 0) goto <D.14710>; else goto <D.14712>;
  <D.14712>:
}


__attribute__((visibility ("hidden")))
mono_thread_hazardous_try_free_some ()
{
  int i;

  i = 0;
  goto <D.14718>;
  <D.14717>:
  try_free_delayed_free_item (0);
  i = i + 1;
  <D.14718>:
  if (i <= 9) goto <D.14717>; else goto <D.14719>;
  <D.14719>:
}


__attribute__((visibility ("hidden")))
mono_thread_smr_init ()
{
  InitializeCriticalSection (&small_id_mutex);
}


__attribute__((visibility ("hidden")))
mono_thread_smr_cleanup ()
{
  mono_thread_hazardous_try_free_all ();
  mono_lock_free_array_queue_cleanup (&delayed_free_queue);
}