__attribute__((visibility ("hidden")))
get_hazardous_pointer_with_mask (void * volatile * pp, struct MonoThreadHazardPointers * hp, int hazard_index)
{
  void * D.5321;
  unsigned int hazard_index.0;
  _Bool D.5323;
  long int D.5324;
  long int D.5325;
  void * D.5328;
  void * D.5329;
  void * p;

  <D.5283>:
  p = *pp;
  if (hp == 0B) goto <D.5319>; else goto <D.5320>;
  <D.5319>:
  D.5321 = p;
  return D.5321;
  <D.5320>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.5323 = hazard_index.0 > 2;
  D.5324 = (long int) D.5323;
  D.5325 = __builtin_expect (D.5324, 0);
  if (D.5325 != 0) goto <D.5326>; else goto <D.5327>;
  <D.5326>:
  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.5327>:
  D.5328 = mono_lls_pointer_unmask (p);
  hp->hazard_pointers[hazard_index] = D.5328;
  mono_memory_write_barrier ();
  mono_memory_barrier ();
  D.5329 = *pp;
  if (D.5329 != p) goto <D.5330>; else goto <D.5331>;
  <D.5330>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.5323 = hazard_index.0 > 2;
  D.5324 = (long int) D.5323;
  D.5325 = __builtin_expect (D.5324, 0);
  if (D.5325 != 0) goto <D.5332>; else goto <D.5333>;
  <D.5332>:
  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.5333>:
  hp->hazard_pointers[hazard_index] = 0B;
  // predicted unlikely by continue predictor.
  goto <D.5281>;
  <D.5331>:
  goto <D.5282>;
  <D.5281>:
  goto <D.5283>;
  <D.5282>:
  D.5321 = p;
  return D.5321;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.5335;
  long unsigned int p.1;
  long unsigned int D.5337;

  p.1 = (long unsigned int) p;
  D.5337 = p.1 & 18446744073709551612;
  D.5335 = (void *) D.5337;
  return D.5335;
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


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


__attribute__((visibility ("hidden")))
mono_lls_find (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, uintptr_t key)
{
  gboolean D.5343;
  struct MonoLinkedListSetNode * * D.5344;
  struct MonoLinkedListSetNode * D.5345;
  long unsigned int D.5347;
  _Bool D.5352;
  void * D.5356;
  void (*<Tc6>) (void *) D.5360;
  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.5339>; else goto <D.5340>;
  <D.5339>:
  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.5340>:
  hp->hazard_pointers[2] = prev;
  mono_memory_write_barrier ();
  cur = get_hazardous_pointer_with_mask (prev, hp, 1);
  <D.5299>:
  if (cur == 0B) goto <D.5341>; else goto <D.5342>;
  <D.5341>:
  D.5343 = 0;
  return D.5343;
  <D.5342>:
  D.5344 = &cur->next;
  next = get_hazardous_pointer_with_mask (D.5344, hp, 0);
  cur_key = cur->key;
  mono_memory_read_barrier ();
  D.5345 = *prev;
  if (D.5345 != cur) goto try_again; else goto <D.5346>;
  <D.5346>:
  D.5347 = mono_lls_pointer_get_mark (next);
  if (D.5347 == 0) goto <D.5348>; else goto <D.5349>;
  <D.5348>:
  if (cur_key >= key) goto <D.5350>; else goto <D.5351>;
  <D.5350>:
  D.5352 = cur_key == key;
  D.5343 = (gboolean) D.5352;
  return D.5343;
  <D.5351>:
  prev = &cur->next;
  if (0 != 0) goto <D.5353>; else goto <D.5354>;
  <D.5353>:
  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.5354>:
  hp->hazard_pointers[2] = cur;
  mono_memory_write_barrier ();
  goto <D.5355>;
  <D.5349>:
  next = mono_lls_pointer_unmask (next);
  D.5356 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.5356 == cur) goto <D.5357>; else goto try_again;
  <D.5357>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.5358>; else goto <D.5359>;
  <D.5358>:
  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.5359>:
  hp->hazard_pointers[1] = 0B;
  D.5360 = list->free_node_func;
  if (D.5360 != 0B) goto <D.5361>; else goto <D.5362>;
  <D.5361>:
  D.5360 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (cur, D.5360, 0, 1);
  <D.5362>:
  <D.5355>:
  cur = mono_lls_pointer_unmask (next);
  if (0 != 0) goto <D.5363>; else goto <D.5364>;
  <D.5363>:
  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.5364>:
  hp->hazard_pointers[1] = cur;
  mono_memory_write_barrier ();
  goto <D.5299>;
}


mono_memory_read_barrier ()
{
  mono_memory_barrier ();
}


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

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


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.5369;
  long unsigned int comp.3;
  long unsigned int exch.4;
  long unsigned int D.5372;

  comp.3 = (long unsigned int) comp;
  exch.4 = (long unsigned int) exch;
  D.5372 = __sync_val_compare_and_swap_8 (dest, comp.3, exch.4);
  D.5369 = (void *) D.5372;
  return D.5369;
}


__attribute__((visibility ("hidden")))
mono_lls_insert (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  long unsigned int D.5374;
  int D.5375;
  gboolean D.5378;
  void * D.5381;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;

  mono_memory_barrier ();
  <D.5307>:
  D.5374 = value->key;
  D.5375 = mono_lls_find (list, hp, D.5374);
  if (D.5375 != 0) goto <D.5376>; else goto <D.5377>;
  <D.5376>:
  D.5378 = 0;
  return D.5378;
  <D.5377>:
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  value->next = cur;
  if (0 != 0) goto <D.5379>; else goto <D.5380>;
  <D.5379>:
  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.5380>:
  hp->hazard_pointers[0] = value;
  mono_memory_write_barrier ();
  mono_memory_write_barrier ();
  D.5381 = InterlockedCompareExchangePointer (prev, value, cur);
  if (D.5381 == cur) goto <D.5382>; else goto <D.5383>;
  <D.5382>:
  D.5378 = 1;
  return D.5378;
  <D.5383>:
  goto <D.5307>;
}


__attribute__((visibility ("hidden")))
mono_lls_remove (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  long unsigned int D.5385;
  int D.5386;
  gboolean D.5389;
  _Bool D.5390;
  long int D.5391;
  long int D.5392;
  struct MonoLinkedListSetNode * * D.5395;
  void * D.5396;
  void * D.5397;
  void * D.5400;
  void (*<Tc6>) (void *) D.5405;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;
  struct MonoLinkedListSetNode * next;

  <D.5317>:
  D.5385 = value->key;
  D.5386 = mono_lls_find (list, hp, D.5385);
  if (D.5386 == 0) goto <D.5387>; else goto <D.5388>;
  <D.5387>:
  D.5389 = 0;
  return D.5389;
  <D.5388>:
  next = hp->hazard_pointers[0];
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  D.5390 = cur != value;
  D.5391 = (long int) D.5390;
  D.5392 = __builtin_expect (D.5391, 0);
  if (D.5392 != 0) goto <D.5393>; else goto <D.5394>;
  <D.5393>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 185, "cur == value");
  <D.5394>:
  D.5395 = &cur->next;
  D.5396 = mask (next, 1);
  D.5397 = InterlockedCompareExchangePointer (D.5395, D.5396, next);
  if (D.5397 != next) goto <D.5398>; else goto <D.5399>;
  <D.5398>:
  // predicted unlikely by continue predictor.
  goto <D.5316>;
  <D.5399>:
  mono_memory_write_barrier ();
  D.5400 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.5400 == cur) goto <D.5401>; else goto <D.5402>;
  <D.5401>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.5403>; else goto <D.5404>;
  <D.5403>:
  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.5404>:
  hp->hazard_pointers[1] = 0B;
  D.5405 = list->free_node_func;
  if (D.5405 != 0B) goto <D.5406>; else goto <D.5407>;
  <D.5406>:
  D.5405 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (value, D.5405, 0, 1);
  <D.5407>:
  goto <D.5408>;
  <D.5402>:
  D.5385 = value->key;
  mono_lls_find (list, hp, D.5385);
  <D.5408>:
  D.5389 = 1;
  return D.5389;
  <D.5316>:
  goto <D.5317>;
}


mask (void * n, uintptr_t bit)
{
  void * D.5410;
  long unsigned int n.5;
  long unsigned int D.5412;

  n.5 = (long unsigned int) n;
  D.5412 = n.5 | bit;
  D.5410 = (void *) D.5412;
  return D.5410;
}