get_hazardous_pointer_with_mask (void * volatile * pp, struct MonoThreadHazardPointers * hp, int hazard_index)
{
  void * D.4838;
  unsigned int hazard_index.0;
  _Bool D.4840;
  long int D.4841;
  long int D.4842;
  void * D.4845;
  void * D.4846;
  void * p;

  <D.4800>:
  p = *pp;
  if (hp == 0B) goto <D.4836>; else goto <D.4837>;
  <D.4836>:
  D.4838 = p;
  return D.4838;
  <D.4837>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.4840 = hazard_index.0 > 2;
  D.4841 = (long int) D.4840;
  D.4842 = __builtin_expect (D.4841, 0);
  if (D.4842 != 0) goto <D.4843>; else goto <D.4844>;
  <D.4843>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 40, "(hazard_index) >= 0 && (hazard_index) < HAZARD_POINTER_COUNT");
  <D.4844>:
  D.4845 = mono_lls_pointer_unmask (p);
  hp->hazard_pointers[hazard_index] = D.4845;
  mono_memory_write_barrier ();
  mono_memory_barrier ();
  D.4846 = *pp;
  if (D.4846 != p) goto <D.4847>; else goto <D.4848>;
  <D.4847>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.4840 = hazard_index.0 > 2;
  D.4841 = (long int) D.4840;
  D.4842 = __builtin_expect (D.4841, 0);
  if (D.4842 != 0) goto <D.4849>; else goto <D.4850>;
  <D.4849>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 47, "(hazard_index) >= 0 && (hazard_index) < HAZARD_POINTER_COUNT");
  <D.4850>:
  hp->hazard_pointers[hazard_index] = 0B;
  // predicted unlikely by continue predictor.
  goto <D.4798>;
  <D.4848>:
  goto <D.4799>;
  <D.4798>:
  goto <D.4800>;
  <D.4799>:
  D.4838 = p;
  return D.4838;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.4852;
  unsigned int p.1;
  unsigned int D.4854;

  p.1 = (unsigned int) p;
  D.4854 = p.1 & 4294967292;
  D.4852 = (void *) D.4854;
  return D.4852;
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_lls_init (struct MonoLinkedListSet * list, void (*<Tc3>) (void *) free_node_func)
{
  list->head = 0B;
  list->free_node_func = free_node_func;
}


mono_lls_find (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, uintptr_t key)
{
  gboolean D.4860;
  struct MonoLinkedListSetNode * * D.4861;
  struct MonoLinkedListSetNode * D.4862;
  unsigned int D.4864;
  _Bool D.4869;
  void * D.4873;
  void (*<Tc3>) (void *) D.4877;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * next;
  struct MonoLinkedListSetNode * * prev;
  uintptr_t cur_key;
  void try_again = <<< error >>>;

  try_again:
  prev = &list->head;
  if (0 != 0) goto <D.4856>; else goto <D.4857>;
  <D.4856>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 95, "(2) >= 0 && (2) < HAZARD_POINTER_COUNT");
  <D.4857>:
  hp->hazard_pointers[2] = prev;
  mono_memory_write_barrier ();
  cur = get_hazardous_pointer_with_mask (prev, hp, 1);
  <D.4816>:
  if (cur == 0B) goto <D.4858>; else goto <D.4859>;
  <D.4858>:
  D.4860 = 0;
  return D.4860;
  <D.4859>:
  D.4861 = &cur->next;
  next = get_hazardous_pointer_with_mask (D.4861, hp, 0);
  cur_key = cur->key;
  mono_memory_read_barrier ();
  D.4862 = *prev;
  if (D.4862 != cur) goto try_again; else goto <D.4863>;
  <D.4863>:
  D.4864 = mono_lls_pointer_get_mark (next);
  if (D.4864 == 0) goto <D.4865>; else goto <D.4866>;
  <D.4865>:
  if (cur_key >= key) goto <D.4867>; else goto <D.4868>;
  <D.4867>:
  D.4869 = cur_key == key;
  D.4860 = (gboolean) D.4869;
  return D.4860;
  <D.4868>:
  prev = &cur->next;
  if (0 != 0) goto <D.4870>; else goto <D.4871>;
  <D.4870>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 120, "(2) >= 0 && (2) < HAZARD_POINTER_COUNT");
  <D.4871>:
  hp->hazard_pointers[2] = cur;
  mono_memory_write_barrier ();
  goto <D.4872>;
  <D.4866>:
  next = mono_lls_pointer_unmask (next);
  D.4873 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.4873 == cur) goto <D.4874>; else goto try_again;
  <D.4874>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4875>; else goto <D.4876>;
  <D.4875>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 126, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.4876>:
  hp->hazard_pointers[1] = 0B;
  D.4877 = list->free_node_func;
  if (D.4877 != 0B) goto <D.4878>; else goto <D.4879>;
  <D.4878>:
  D.4877 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (cur, D.4877, 0, 1);
  <D.4879>:
  <D.4872>:
  cur = mono_lls_pointer_unmask (next);
  if (0 != 0) goto <D.4880>; else goto <D.4881>;
  <D.4880>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 133, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.4881>:
  hp->hazard_pointers[1] = cur;
  mono_memory_write_barrier ();
  goto <D.4816>;
}


mono_memory_read_barrier ()
{
  mono_memory_barrier ();
}


mono_lls_pointer_get_mark (void * n)
{
  uintptr_t D.4883;
  unsigned int n.2;

  n.2 = (unsigned int) n;
  D.4883 = n.2 & 1;
  return D.4883;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.4886;
  unsigned int comp.3;
  unsigned int exch.4;
  unsigned int D.4889;

  comp.3 = (unsigned int) comp;
  exch.4 = (unsigned int) exch;
  D.4889 = __sync_val_compare_and_swap_4 (dest, comp.3, exch.4);
  D.4886 = (void *) D.4889;
  return D.4886;
}


mono_lls_insert (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  unsigned int D.4891;
  int D.4892;
  gboolean D.4895;
  void * D.4898;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;

  mono_memory_barrier ();
  <D.4824>:
  D.4891 = value->key;
  D.4892 = mono_lls_find (list, hp, D.4891);
  if (D.4892 != 0) goto <D.4893>; else goto <D.4894>;
  <D.4893>:
  D.4895 = 0;
  return D.4895;
  <D.4894>:
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  value->next = cur;
  if (0 != 0) goto <D.4896>; else goto <D.4897>;
  <D.4896>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 159, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.4897>:
  hp->hazard_pointers[0] = value;
  mono_memory_write_barrier ();
  mono_memory_write_barrier ();
  D.4898 = InterlockedCompareExchangePointer (prev, value, cur);
  if (D.4898 == cur) goto <D.4899>; else goto <D.4900>;
  <D.4899>:
  D.4895 = 1;
  return D.4895;
  <D.4900>:
  goto <D.4824>;
}


mono_lls_remove (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  unsigned int D.4902;
  int D.4903;
  gboolean D.4906;
  _Bool D.4907;
  long int D.4908;
  long int D.4909;
  struct MonoLinkedListSetNode * * D.4912;
  void * D.4913;
  void * D.4914;
  void * D.4917;
  void (*<Tc3>) (void *) D.4922;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;
  struct MonoLinkedListSetNode * next;

  <D.4834>:
  D.4902 = value->key;
  D.4903 = mono_lls_find (list, hp, D.4902);
  if (D.4903 == 0) goto <D.4904>; else goto <D.4905>;
  <D.4904>:
  D.4906 = 0;
  return D.4906;
  <D.4905>:
  next = hp->hazard_pointers[0];
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  D.4907 = cur != value;
  D.4908 = (long int) D.4907;
  D.4909 = __builtin_expect (D.4908, 0);
  if (D.4909 != 0) goto <D.4910>; else goto <D.4911>;
  <D.4910>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 185, "cur == value");
  <D.4911>:
  D.4912 = &cur->next;
  D.4913 = mask (next, 1);
  D.4914 = InterlockedCompareExchangePointer (D.4912, D.4913, next);
  if (D.4914 != next) goto <D.4915>; else goto <D.4916>;
  <D.4915>:
  // predicted unlikely by continue predictor.
  goto <D.4833>;
  <D.4916>:
  mono_memory_write_barrier ();
  D.4917 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.4917 == cur) goto <D.4918>; else goto <D.4919>;
  <D.4918>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4920>; else goto <D.4921>;
  <D.4920>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 194, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.4921>:
  hp->hazard_pointers[1] = 0B;
  D.4922 = list->free_node_func;
  if (D.4922 != 0B) goto <D.4923>; else goto <D.4924>;
  <D.4923>:
  D.4922 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (value, D.4922, 0, 1);
  <D.4924>:
  goto <D.4925>;
  <D.4919>:
  D.4902 = value->key;
  mono_lls_find (list, hp, D.4902);
  <D.4925>:
  D.4906 = 1;
  return D.4906;
  <D.4833>:
  goto <D.4834>;
}


mask (void * n, uintptr_t bit)
{
  void * D.4927;
  unsigned int n.5;
  unsigned int D.4929;

  n.5 = (unsigned int) n;
  D.4929 = n.5 | bit;
  D.4927 = (void *) D.4929;
  return D.4927;
}