get_hazardous_pointer_with_mask (void * volatile * pp, struct MonoThreadHazardPointers * hp, int hazard_index)
{
  void * D.4804;
  unsigned int hazard_index.0;
  _Bool D.4806;
  long int D.4807;
  long int D.4808;
  void * D.4811;
  void * D.4812;
  void * p;

  <D.4766>:
  p = *pp;
  if (hp == 0B) goto <D.4802>; else goto <D.4803>;
  <D.4802>:
  D.4804 = p;
  return D.4804;
  <D.4803>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.4806 = hazard_index.0 > 2;
  D.4807 = (long int) D.4806;
  D.4808 = __builtin_expect (D.4807, 0);
  if (D.4808 != 0) goto <D.4809>; else goto <D.4810>;
  <D.4809>:
  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.4810>:
  D.4811 = mono_lls_pointer_unmask (p);
  hp->hazard_pointers[hazard_index] = D.4811;
  mono_memory_write_barrier ();
  mono_memory_barrier ();
  D.4812 = *pp;
  if (D.4812 != p) goto <D.4813>; else goto <D.4814>;
  <D.4813>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.4806 = hazard_index.0 > 2;
  D.4807 = (long int) D.4806;
  D.4808 = __builtin_expect (D.4807, 0);
  if (D.4808 != 0) goto <D.4815>; else goto <D.4816>;
  <D.4815>:
  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.4816>:
  hp->hazard_pointers[hazard_index] = 0B;
  // predicted unlikely by continue predictor.
  goto <D.4764>;
  <D.4814>:
  goto <D.4765>;
  <D.4764>:
  goto <D.4766>;
  <D.4765>:
  D.4804 = p;
  return D.4804;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.4818;
  unsigned int p.1;
  unsigned int D.4820;

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


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_lls_init (struct MonoLinkedListSet * list, void (*<Tbf>) (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.4826;
  struct MonoLinkedListSetNode * * D.4827;
  struct MonoLinkedListSetNode * D.4828;
  unsigned int D.4830;
  _Bool D.4835;
  void * D.4839;
  void (*<Tbf>) (void *) D.4843;
  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.4822>; else goto <D.4823>;
  <D.4822>:
  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.4823>:
  hp->hazard_pointers[2] = prev;
  mono_memory_write_barrier ();
  cur = get_hazardous_pointer_with_mask (prev, hp, 1);
  <D.4782>:
  if (cur == 0B) goto <D.4824>; else goto <D.4825>;
  <D.4824>:
  D.4826 = 0;
  return D.4826;
  <D.4825>:
  D.4827 = &cur->next;
  next = get_hazardous_pointer_with_mask (D.4827, hp, 0);
  cur_key = cur->key;
  mono_memory_read_barrier ();
  D.4828 = *prev;
  if (D.4828 != cur) goto try_again; else goto <D.4829>;
  <D.4829>:
  D.4830 = mono_lls_pointer_get_mark (next);
  if (D.4830 == 0) goto <D.4831>; else goto <D.4832>;
  <D.4831>:
  if (cur_key >= key) goto <D.4833>; else goto <D.4834>;
  <D.4833>:
  D.4835 = cur_key == key;
  D.4826 = (gboolean) D.4835;
  return D.4826;
  <D.4834>:
  prev = &cur->next;
  if (0 != 0) goto <D.4836>; else goto <D.4837>;
  <D.4836>:
  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.4837>:
  hp->hazard_pointers[2] = cur;
  mono_memory_write_barrier ();
  goto <D.4838>;
  <D.4832>:
  next = mono_lls_pointer_unmask (next);
  D.4839 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.4839 == cur) goto <D.4840>; else goto try_again;
  <D.4840>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4841>; else goto <D.4842>;
  <D.4841>:
  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.4842>:
  hp->hazard_pointers[1] = 0B;
  D.4843 = list->free_node_func;
  if (D.4843 != 0B) goto <D.4844>; else goto <D.4845>;
  <D.4844>:
  D.4843 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (cur, D.4843, 0, 1);
  <D.4845>:
  <D.4838>:
  cur = mono_lls_pointer_unmask (next);
  if (0 != 0) goto <D.4846>; else goto <D.4847>;
  <D.4846>:
  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.4847>:
  hp->hazard_pointers[1] = cur;
  mono_memory_write_barrier ();
  goto <D.4782>;
}


mono_memory_read_barrier ()
{
  mono_memory_barrier ();
}


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

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


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

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


mono_lls_insert (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  unsigned int D.4857;
  int D.4858;
  gboolean D.4861;
  void * D.4864;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;

  mono_memory_barrier ();
  <D.4790>:
  D.4857 = value->key;
  D.4858 = mono_lls_find (list, hp, D.4857);
  if (D.4858 != 0) goto <D.4859>; else goto <D.4860>;
  <D.4859>:
  D.4861 = 0;
  return D.4861;
  <D.4860>:
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  value->next = cur;
  if (0 != 0) goto <D.4862>; else goto <D.4863>;
  <D.4862>:
  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.4863>:
  hp->hazard_pointers[0] = value;
  mono_memory_write_barrier ();
  mono_memory_write_barrier ();
  D.4864 = InterlockedCompareExchangePointer (prev, value, cur);
  if (D.4864 == cur) goto <D.4865>; else goto <D.4866>;
  <D.4865>:
  D.4861 = 1;
  return D.4861;
  <D.4866>:
  goto <D.4790>;
}


mono_lls_remove (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  unsigned int D.4868;
  int D.4869;
  gboolean D.4872;
  _Bool D.4873;
  long int D.4874;
  long int D.4875;
  void * D.4878;
  struct MonoLinkedListSetNode * * D.4879;
  void * D.4880;
  void * D.4883;
  void (*<Tbf>) (void *) D.4888;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;
  struct MonoLinkedListSetNode * next;

  <D.4800>:
  D.4868 = value->key;
  D.4869 = mono_lls_find (list, hp, D.4868);
  if (D.4869 == 0) goto <D.4870>; else goto <D.4871>;
  <D.4870>:
  D.4872 = 0;
  return D.4872;
  <D.4871>:
  next = hp->hazard_pointers[0];
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  D.4873 = cur != value;
  D.4874 = (long int) D.4873;
  D.4875 = __builtin_expect (D.4874, 0);
  if (D.4875 != 0) goto <D.4876>; else goto <D.4877>;
  <D.4876>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 185, "cur == value");
  <D.4877>:
  D.4878 = mask (next, 1);
  D.4879 = &cur->next;
  D.4880 = InterlockedCompareExchangePointer (D.4879, D.4878, next);
  if (D.4880 != next) goto <D.4881>; else goto <D.4882>;
  <D.4881>:
  // predicted unlikely by continue predictor.
  goto <D.4799>;
  <D.4882>:
  mono_memory_write_barrier ();
  D.4883 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.4883 == cur) goto <D.4884>; else goto <D.4885>;
  <D.4884>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4886>; else goto <D.4887>;
  <D.4886>:
  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.4887>:
  hp->hazard_pointers[1] = 0B;
  D.4888 = list->free_node_func;
  if (D.4888 != 0B) goto <D.4889>; else goto <D.4890>;
  <D.4889>:
  D.4888 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (value, D.4888, 0, 1);
  <D.4890>:
  goto <D.4891>;
  <D.4885>:
  D.4868 = value->key;
  mono_lls_find (list, hp, D.4868);
  <D.4891>:
  D.4872 = 1;
  return D.4872;
  <D.4799>:
  goto <D.4800>;
}


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

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