get_hazardous_pointer_with_mask (void * volatile * pp, struct MonoThreadHazardPointers * hp, int hazard_index)
{
  void * D.7427;
  unsigned int hazard_index.0;
  _Bool D.7429;
  long int D.7430;
  long int D.7431;
  void * D.7434;
  void * D.7435;
  void * p;

  <D.7387>:
  p = *pp;
  if (hp == 0B) goto <D.7425>; else goto <D.7426>;
  <D.7425>:
  D.7427 = p;
  return D.7427;
  <D.7426>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.7429 = hazard_index.0 > 2;
  D.7430 = (long int) D.7429;
  D.7431 = __builtin_expect (D.7430, 0);
  if (D.7431 != 0) goto <D.7432>; else goto <D.7433>;
  <D.7432>:
  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.7433>:
  D.7434 = mono_lls_pointer_unmask (p);
  hp->hazard_pointers[hazard_index] = D.7434;
  mono_memory_write_barrier ();
  mono_memory_barrier ();
  D.7435 = *pp;
  if (D.7435 != p) goto <D.7436>; else goto <D.7437>;
  <D.7436>:
  hazard_index.0 = (unsigned int) hazard_index;
  D.7429 = hazard_index.0 > 2;
  D.7430 = (long int) D.7429;
  D.7431 = __builtin_expect (D.7430, 0);
  if (D.7431 != 0) goto <D.7438>; else goto <D.7439>;
  <D.7438>:
  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.7439>:
  hp->hazard_pointers[hazard_index] = 0B;
  // predicted unlikely by continue predictor.
  goto <D.7385>;
  <D.7437>:
  goto <D.7386>;
  <D.7385>:
  goto <D.7387>;
  <D.7386>:
  D.7427 = p;
  return D.7427;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.7441;
  unsigned int p.1;
  unsigned int D.7443;

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


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_lls_init (struct MonoLinkedListSet * list, void (*<Tc1>) (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.7449;
  struct MonoLinkedListSetNode * * D.7450;
  struct MonoLinkedListSetNode * D.7451;
  unsigned int D.7453;
  _Bool D.7458;
  void * D.7462;
  void (*<Tc1>) (void *) D.7466;
  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.7445>; else goto <D.7446>;
  <D.7445>:
  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.7446>:
  hp->hazard_pointers[2] = prev;
  mono_memory_write_barrier ();
  cur = get_hazardous_pointer_with_mask (prev, hp, 1);
  <D.7403>:
  if (cur == 0B) goto <D.7447>; else goto <D.7448>;
  <D.7447>:
  D.7449 = 0;
  return D.7449;
  <D.7448>:
  D.7450 = &cur->next;
  next = get_hazardous_pointer_with_mask (D.7450, hp, 0);
  cur_key = cur->key;
  mono_memory_read_barrier ();
  D.7451 = *prev;
  if (D.7451 != cur) goto try_again; else goto <D.7452>;
  <D.7452>:
  D.7453 = mono_lls_pointer_get_mark (next);
  if (D.7453 == 0) goto <D.7454>; else goto <D.7455>;
  <D.7454>:
  if (cur_key >= key) goto <D.7456>; else goto <D.7457>;
  <D.7456>:
  D.7458 = cur_key == key;
  D.7449 = (gboolean) D.7458;
  return D.7449;
  <D.7457>:
  prev = &cur->next;
  if (0 != 0) goto <D.7459>; else goto <D.7460>;
  <D.7459>:
  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.7460>:
  hp->hazard_pointers[2] = cur;
  mono_memory_write_barrier ();
  goto <D.7461>;
  <D.7455>:
  next = mono_lls_pointer_unmask (next);
  D.7462 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.7462 == cur) goto <D.7463>; else goto try_again;
  <D.7463>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.7464>; else goto <D.7465>;
  <D.7464>:
  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.7465>:
  hp->hazard_pointers[1] = 0B;
  D.7466 = list->free_node_func;
  if (D.7466 != 0B) goto <D.7467>; else goto <D.7468>;
  <D.7467>:
  D.7466 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (cur, D.7466, 0, 1);
  <D.7468>:
  <D.7461>:
  cur = mono_lls_pointer_unmask (next);
  if (0 != 0) goto <D.7469>; else goto <D.7470>;
  <D.7469>:
  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.7470>:
  hp->hazard_pointers[1] = cur;
  mono_memory_write_barrier ();
  goto <D.7403>;
}


mono_memory_read_barrier ()
{
  mono_memory_barrier ();
}


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

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


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

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


mono_lls_insert (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  unsigned int D.7480;
  int D.7481;
  gboolean D.7484;
  void * D.7487;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;

  mono_memory_barrier ();
  <D.7411>:
  D.7480 = value->key;
  D.7481 = mono_lls_find (list, hp, D.7480);
  if (D.7481 != 0) goto <D.7482>; else goto <D.7483>;
  <D.7482>:
  D.7484 = 0;
  return D.7484;
  <D.7483>:
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  value->next = cur;
  if (0 != 0) goto <D.7485>; else goto <D.7486>;
  <D.7485>:
  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.7486>:
  hp->hazard_pointers[0] = value;
  mono_memory_write_barrier ();
  mono_memory_write_barrier ();
  D.7487 = InterlockedCompareExchangePointer (prev, value, cur);
  if (D.7487 == cur) goto <D.7488>; else goto <D.7489>;
  <D.7488>:
  D.7484 = 1;
  return D.7484;
  <D.7489>:
  goto <D.7411>;
}


mono_lls_remove (struct MonoLinkedListSet * list, struct MonoThreadHazardPointers * hp, struct MonoLinkedListSetNode * value)
{
  unsigned int D.7491;
  int D.7492;
  gboolean D.7495;
  _Bool D.7496;
  long int D.7497;
  long int D.7498;
  struct MonoLinkedListSetNode * * D.7501;
  void * D.7502;
  void * D.7503;
  void * D.7506;
  void (*<Tc1>) (void *) D.7511;
  struct MonoLinkedListSetNode * cur;
  struct MonoLinkedListSetNode * * prev;
  struct MonoLinkedListSetNode * next;

  <D.7421>:
  D.7491 = value->key;
  D.7492 = mono_lls_find (list, hp, D.7491);
  if (D.7492 == 0) goto <D.7493>; else goto <D.7494>;
  <D.7493>:
  D.7495 = 0;
  return D.7495;
  <D.7494>:
  next = hp->hazard_pointers[0];
  cur = hp->hazard_pointers[1];
  prev = hp->hazard_pointers[2];
  D.7496 = cur != value;
  D.7497 = (long int) D.7496;
  D.7498 = __builtin_expect (D.7497, 0);
  if (D.7498 != 0) goto <D.7499>; else goto <D.7500>;
  <D.7499>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-linked-list-set.c", 185, "cur == value");
  <D.7500>:
  D.7501 = &cur->next;
  D.7502 = mask (next, 1);
  D.7503 = InterlockedCompareExchangePointer (D.7501, D.7502, next);
  if (D.7503 != next) goto <D.7504>; else goto <D.7505>;
  <D.7504>:
  // predicted unlikely by continue predictor.
  goto <D.7420>;
  <D.7505>:
  mono_memory_write_barrier ();
  D.7506 = InterlockedCompareExchangePointer (prev, next, cur);
  if (D.7506 == cur) goto <D.7507>; else goto <D.7508>;
  <D.7507>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.7509>; else goto <D.7510>;
  <D.7509>:
  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.7510>:
  hp->hazard_pointers[1] = 0B;
  D.7511 = list->free_node_func;
  if (D.7511 != 0B) goto <D.7512>; else goto <D.7513>;
  <D.7512>:
  D.7511 = list->free_node_func;
  mono_thread_hazardous_free_or_queue (value, D.7511, 0, 1);
  <D.7513>:
  goto <D.7514>;
  <D.7508>:
  D.7491 = value->key;
  mono_lls_find (list, hp, D.7491);
  <D.7514>:
  D.7495 = 1;
  return D.7495;
  <D.7420>:
  goto <D.7421>;
}


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

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