mono_lock_free_queue_init (struct MonoLockFreeQueue * q)
{
  struct MonoLockFreeQueueNode * volatile iftmp.0;
  _Bool D.4834;
  int D.4835;
  struct MonoLockFreeQueueNode * D.4836;
  struct MonoLockFreeQueueNode * D.4837;
  int i;

  i = 0;
  goto <D.4779>;
  <D.4778>:
  if (i == 0) goto <D.4831>; else goto <D.4832>;
  <D.4831>:
  iftmp.0 = 4294967294B;
  goto <D.4833>;
  <D.4832>:
  iftmp.0 = 4294967293B;
  <D.4833>:
  q->dummies[i].node.next = iftmp.0;
  D.4834 = i == 0;
  D.4835 = (int) D.4834;
  q->dummies[i].in_use = D.4835;
  i = i + 1;
  <D.4779>:
  if (i <= 1) goto <D.4778>; else goto <D.4780>;
  <D.4780>:
  D.4836 = &q->dummies[0].node;
  D.4837 = D.4836;
  q->tail = D.4837;
  q->head = D.4837;
  q->has_dummy = 1;
}


mono_lock_free_queue_node_init (struct MonoLockFreeQueueNode * node, gboolean to_be_freed)
{
  struct MonoLockFreeQueueNode * volatile iftmp.1;

  if (to_be_freed != 0) goto <D.4839>; else goto <D.4840>;
  <D.4839>:
  iftmp.1 = 4294967295B;
  goto <D.4841>;
  <D.4840>:
  iftmp.1 = 4294967293B;
  <D.4841>:
  node->next = iftmp.1;
}


mono_lock_free_queue_node_free (struct MonoLockFreeQueueNode * node)
{
  struct MonoLockFreeQueueNode * D.4842;
  _Bool D.4843;
  long int D.4844;
  long int D.4845;

  D.4842 = node->next;
  D.4843 = D.4842 != 4294967295B;
  D.4844 = (long int) D.4843;
  D.4845 = __builtin_expect (D.4844, 0);
  if (D.4845 != 0) goto <D.4846>; else goto <D.4847>;
  <D.4846>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 92, "node->next == INVALID_NEXT");
  <D.4847>:
  node->next = 4294967293B;
}


mono_lock_free_queue_enqueue (struct MonoLockFreeQueue * q, struct MonoLockFreeQueueNode * node)
{
  struct MonoLockFreeQueueNode * D.4848;
  _Bool D.4849;
  long int D.4850;
  long int D.4851;
  struct MonoLockFreeQueueNode * volatile * D.4854;
  struct MonoLockFreeQueueNode * D.4855;
  int iftmp.2;
  _Bool D.4863;
  long int D.4864;
  long int D.4865;
  _Bool D.4868;
  long int D.4869;
  long int D.4870;
  struct MonoLockFreeQueueNode * volatile * D.4875;
  void * D.4876;
  struct MonoLockFreeQueueNode * volatile * D.4879;
  struct MonoLockFreeQueueNode * volatile * D.4882;
  struct MonoThreadHazardPointers * hp;
  struct MonoLockFreeQueueNode * tail;

  hp = mono_hazard_pointer_get ();
  D.4848 = node->next;
  D.4849 = D.4848 != 4294967293B;
  D.4850 = (long int) D.4849;
  D.4851 = __builtin_expect (D.4850, 0);
  if (D.4851 != 0) goto <D.4852>; else goto <D.4853>;
  <D.4852>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 111, "node->next == FREE_NEXT");
  <D.4853>:
  node->next = 4294967294B;
  <D.4796>:
  {
    struct MonoLockFreeQueueNode * next;

    D.4854 = &q->tail;
    tail = get_hazardous_pointer (D.4854, hp, 0);
    mono_memory_read_barrier ();
    next = tail->next;
    mono_memory_read_barrier ();
    D.4855 = q->tail;
    if (D.4855 == tail) goto <D.4856>; else goto <D.4857>;
    <D.4856>:
    if (next == 4294967295B) goto <D.4859>; else goto <D.4862>;
    <D.4862>:
    if (next == 4294967293B) goto <D.4859>; else goto <D.4860>;
    <D.4859>:
    iftmp.2 = 1;
    goto <D.4861>;
    <D.4860>:
    iftmp.2 = 0;
    <D.4861>:
    D.4863 = iftmp.2 != 0;
    D.4864 = (long int) D.4863;
    D.4865 = __builtin_expect (D.4864, 0);
    if (D.4865 != 0) goto <D.4866>; else goto <D.4867>;
    <D.4866>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 127, "next != INVALID_NEXT && next != FREE_NEXT");
    <D.4867>:
    D.4868 = next == tail;
    D.4869 = (long int) D.4868;
    D.4870 = __builtin_expect (D.4869, 0);
    if (D.4870 != 0) goto <D.4871>; else goto <D.4872>;
    <D.4871>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 128, "next != tail");
    <D.4872>:
    if (next == 4294967294B) goto <D.4873>; else goto <D.4874>;
    <D.4873>:
    D.4875 = &tail->next;
    D.4876 = InterlockedCompareExchangePointer (D.4875, node, 4294967294B);
    if (D.4876 == 4294967294B) goto <D.4795>; else goto <D.4877>;
    <D.4877>:
    goto <D.4878>;
    <D.4874>:
    D.4879 = &q->tail;
    InterlockedCompareExchangePointer (D.4879, next, tail);
    <D.4878>:
    <D.4857>:
    mono_memory_write_barrier ();
    if (0 != 0) goto <D.4880>; else goto <D.4881>;
    <D.4880>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 147, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.4881>:
    hp->hazard_pointers[0] = 0B;
  }
  goto <D.4796>;
  <D.4795>:
  D.4882 = &q->tail;
  InterlockedCompareExchangePointer (D.4882, node, tail);
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4883>; else goto <D.4884>;
  <D.4883>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 154, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.4884>:
  hp->hazard_pointers[0] = 0B;
}


mono_memory_read_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


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

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


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_lock_free_queue_dequeue (struct MonoLockFreeQueue * q)
{
  struct MonoLockFreeQueueNode * volatile * D.4890;
  struct MonoLockFreeQueueNode * D.4891;
  int iftmp.5;
  _Bool D.4899;
  long int D.4900;
  long int D.4901;
  _Bool D.4904;
  long int D.4905;
  long int D.4906;
  int D.4915;
  int D.4918;
  struct MonoLockFreeQueueNode * D.4921;
  struct MonoLockFreeQueueNode * volatile * D.4922;
  _Bool D.4924;
  long int D.4925;
  long int D.4926;
  struct MonoLockFreeQueueNode * volatile * D.4929;
  void * D.4930;
  struct MonoLockFreeQueueNode * D.4936;
  _Bool D.4937;
  long int D.4938;
  long int D.4939;
  int D.4942;
  int D.4945;
  _Bool D.4946;
  long int D.4947;
  long int D.4948;
  int D.4951;
  struct MonoThreadHazardPointers * hp;
  struct MonoLockFreeQueueNode * head;
  void retry = <<< error >>>;

  hp = mono_hazard_pointer_get ();
  retry:
  <D.4828>:
  {
    struct MonoLockFreeQueueNode * tail;
    struct MonoLockFreeQueueNode * next;

    D.4890 = &q->head;
    head = get_hazardous_pointer (D.4890, hp, 0);
    tail = q->tail;
    mono_memory_read_barrier ();
    next = head->next;
    mono_memory_read_barrier ();
    D.4891 = q->head;
    if (D.4891 == head) goto <D.4892>; else goto <D.4893>;
    <D.4892>:
    if (next == 4294967295B) goto <D.4895>; else goto <D.4898>;
    <D.4898>:
    if (next == 4294967293B) goto <D.4895>; else goto <D.4896>;
    <D.4895>:
    iftmp.5 = 1;
    goto <D.4897>;
    <D.4896>:
    iftmp.5 = 0;
    <D.4897>:
    D.4899 = iftmp.5 != 0;
    D.4900 = (long int) D.4899;
    D.4901 = __builtin_expect (D.4900, 0);
    if (D.4901 != 0) goto <D.4902>; else goto <D.4903>;
    <D.4902>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 229, "next != INVALID_NEXT && next != FREE_NEXT");
    <D.4903>:
    D.4904 = next == head;
    D.4905 = (long int) D.4904;
    D.4906 = __builtin_expect (D.4905, 0);
    if (D.4906 != 0) goto <D.4907>; else goto <D.4908>;
    <D.4907>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 230, "next != head");
    <D.4908>:
    if (head == tail) goto <D.4909>; else goto <D.4910>;
    <D.4909>:
    if (next == 4294967294B) goto <D.4911>; else goto <D.4912>;
    <D.4911>:
    if (0 != 0) goto <D.4913>; else goto <D.4914>;
    <D.4913>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 236, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.4914>:
    hp->hazard_pointers[0] = 0B;
    D.4915 = is_dummy (q, head);
    if (D.4915 == 0) goto <D.4916>; else goto <D.4917>;
    <D.4916>:
    D.4918 = try_reenqueue_dummy (q);
    if (D.4918 != 0) goto <D.4919>; else goto <D.4920>;
    <D.4919>:
    // predicted unlikely by continue predictor.
    goto <D.4826>;
    <D.4920>:
    <D.4917>:
    D.4921 = 0B;
    return D.4921;
    <D.4912>:
    D.4922 = &q->tail;
    InterlockedCompareExchangePointer (D.4922, next, tail);
    goto <D.4923>;
    <D.4910>:
    D.4924 = next == 4294967294B;
    D.4925 = (long int) D.4924;
    D.4926 = __builtin_expect (D.4925, 0);
    if (D.4926 != 0) goto <D.4927>; else goto <D.4928>;
    <D.4927>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 254, "next != END_MARKER");
    <D.4928>:
    D.4929 = &q->head;
    D.4930 = InterlockedCompareExchangePointer (D.4929, next, head);
    if (D.4930 == head) goto <D.4827>; else goto <D.4931>;
    <D.4931>:
    <D.4923>:
    <D.4893>:
    mono_memory_write_barrier ();
    if (0 != 0) goto <D.4932>; else goto <D.4933>;
    <D.4932>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 262, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.4933>:
    hp->hazard_pointers[0] = 0B;
  }
  <D.4826>:
  goto <D.4828>;
  <D.4827>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4934>; else goto <D.4935>;
  <D.4934>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 270, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.4935>:
  hp->hazard_pointers[0] = 0B;
  D.4936 = head->next;
  D.4937 = D.4936 == 0B;
  D.4938 = (long int) D.4937;
  D.4939 = __builtin_expect (D.4938, 0);
  if (D.4939 != 0) goto <D.4940>; else goto <D.4941>;
  <D.4940>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 272, "head->next");
  <D.4941>:
  head->next = 4294967295B;
  D.4942 = is_dummy (q, head);
  if (D.4942 != 0) goto <D.4943>; else goto <D.4944>;
  <D.4943>:
  D.4945 = q->has_dummy;
  D.4946 = D.4945 == 0;
  D.4947 = (long int) D.4946;
  D.4948 = __builtin_expect (D.4947, 0);
  if (D.4948 != 0) goto <D.4949>; else goto <D.4950>;
  <D.4949>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 286, "q->has_dummy");
  <D.4950>:
  q->has_dummy = 0;
  mono_memory_write_barrier ();
  mono_thread_hazardous_free_or_queue (head, free_dummy, 0, 1);
  D.4951 = try_reenqueue_dummy (q);
  if (D.4951 != 0) goto retry; else goto <D.4952>;
  <D.4952>:
  D.4921 = 0B;
  return D.4921;
  <D.4944>:
  D.4921 = head;
  return D.4921;
}


free_dummy (void * _dummy)
{
  struct MonoLockFreeQueueNode * D.4954;
  int D.4955;
  _Bool D.4956;
  long int D.4957;
  long int D.4958;
  struct MonoLockFreeQueueDummy * dummy;

  dummy = _dummy;
  D.4954 = &dummy->node;
  mono_lock_free_queue_node_free (D.4954);
  D.4955 = dummy->in_use;
  D.4956 = D.4955 == 0;
  D.4957 = (long int) D.4956;
  D.4958 = __builtin_expect (D.4957, 0);
  if (D.4958 != 0) goto <D.4959>; else goto <D.4960>;
  <D.4959>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 162, "dummy->in_use");
  <D.4960>:
  mono_memory_write_barrier ();
  dummy->in_use = 0;
}


is_dummy (struct MonoLockFreeQueue * q, struct MonoLockFreeQueueNode * n)
{
  gboolean D.4961;
  int iftmp.6;
  struct MonoLockFreeQueueNode * D.4965;
  struct MonoLockFreeQueueNode * D.4967;

  D.4965 = &q->dummies[0].node;
  if (D.4965 <= n) goto <D.4966>; else goto <D.4963>;
  <D.4966>:
  D.4967 = &q->dummies[2].node;
  if (D.4967 > n) goto <D.4968>; else goto <D.4963>;
  <D.4968>:
  iftmp.6 = 1;
  goto <D.4964>;
  <D.4963>:
  iftmp.6 = 0;
  <D.4964>:
  D.4961 = iftmp.6;
  return D.4961;
}


try_reenqueue_dummy (struct MonoLockFreeQueue * q)
{
  int D.4970;
  gboolean D.4973;
  volatile gint32 * D.4976;
  int D.4977;
  struct MonoLockFreeQueueNode * D.4980;
  struct MonoLockFreeQueueDummy * dummy;

  D.4970 = q->has_dummy;
  if (D.4970 != 0) goto <D.4971>; else goto <D.4972>;
  <D.4971>:
  D.4973 = 0;
  return D.4973;
  <D.4972>:
  dummy = get_dummy (q);
  if (dummy == 0B) goto <D.4974>; else goto <D.4975>;
  <D.4974>:
  D.4973 = 0;
  return D.4973;
  <D.4975>:
  D.4976 = &q->has_dummy;
  D.4977 = InterlockedCompareExchange (D.4976, 1, 0);
  if (D.4977 != 0) goto <D.4978>; else goto <D.4979>;
  <D.4978>:
  dummy->in_use = 0;
  D.4973 = 0;
  return D.4973;
  <D.4979>:
  D.4980 = &dummy->node;
  mono_lock_free_queue_enqueue (q, D.4980);
  D.4973 = 1;
  return D.4973;
}


get_dummy (struct MonoLockFreeQueue * q)
{
  int D.4982;
  volatile gint32 * D.4985;
  int D.4986;
  struct MonoLockFreeQueueDummy * D.4989;
  int i;

  i = 0;
  goto <D.4808>;
  <D.4807>:
  {
    struct MonoLockFreeQueueDummy * dummy;

    dummy = &q->dummies[i];
    D.4982 = dummy->in_use;
    if (D.4982 != 0) goto <D.4983>; else goto <D.4984>;
    <D.4983>:
    // predicted unlikely by continue predictor.
    goto <D.4806>;
    <D.4984>:
    D.4985 = &dummy->in_use;
    D.4986 = InterlockedCompareExchange (D.4985, 1, 0);
    if (D.4986 == 0) goto <D.4987>; else goto <D.4988>;
    <D.4987>:
    D.4989 = dummy;
    return D.4989;
    <D.4988>:
  }
  <D.4806>:
  i = i + 1;
  <D.4808>:
  if (i <= 1) goto <D.4807>; else goto <D.4809>;
  <D.4809>:
  D.4989 = 0B;
  return D.4989;
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.4991;
  unsigned int comp.7;
  unsigned int exch.8;
  unsigned int D.4994;

  comp.7 = (unsigned int) comp;
  exch.8 = (unsigned int) exch;
  D.4994 = __sync_val_compare_and_swap_4 (dest, comp.7, exch.8);
  D.4991 = (gint32) D.4994;
  return D.4991;
}