mono_lock_free_queue_init (struct MonoLockFreeQueue * q)
{
  struct MonoLockFreeQueueNode * volatile iftmp.0;
  _Bool D.4800;
  int D.4801;
  struct MonoLockFreeQueueNode * D.4802;
  struct MonoLockFreeQueueNode * D.4803;
  int i;

  i = 0;
  goto <D.4745>;
  <D.4744>:
  if (i == 0) goto <D.4797>; else goto <D.4798>;
  <D.4797>:
  iftmp.0 = 4294967294B;
  goto <D.4799>;
  <D.4798>:
  iftmp.0 = 4294967293B;
  <D.4799>:
  q->dummies[i].node.next = iftmp.0;
  D.4800 = i == 0;
  D.4801 = (int) D.4800;
  q->dummies[i].in_use = D.4801;
  i = i + 1;
  <D.4745>:
  if (i <= 1) goto <D.4744>; else goto <D.4746>;
  <D.4746>:
  D.4802 = &q->dummies[0].node;
  D.4803 = D.4802;
  q->tail = D.4803;
  q->head = D.4803;
  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.4805>; else goto <D.4806>;
  <D.4805>:
  iftmp.1 = 4294967295B;
  goto <D.4807>;
  <D.4806>:
  iftmp.1 = 4294967293B;
  <D.4807>:
  node->next = iftmp.1;
}


mono_lock_free_queue_node_free (struct MonoLockFreeQueueNode * node)
{
  struct MonoLockFreeQueueNode * D.4808;
  _Bool D.4809;
  long int D.4810;
  long int D.4811;

  D.4808 = node->next;
  D.4809 = D.4808 != 4294967295B;
  D.4810 = (long int) D.4809;
  D.4811 = __builtin_expect (D.4810, 0);
  if (D.4811 != 0) goto <D.4812>; else goto <D.4813>;
  <D.4812>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 92, "node->next == INVALID_NEXT");
  <D.4813>:
  node->next = 4294967293B;
}


mono_lock_free_queue_enqueue (struct MonoLockFreeQueue * q, struct MonoLockFreeQueueNode * node)
{
  struct MonoLockFreeQueueNode * D.4814;
  _Bool D.4815;
  long int D.4816;
  long int D.4817;
  struct MonoLockFreeQueueNode * volatile * D.4820;
  struct MonoLockFreeQueueNode * D.4821;
  _Bool D.4824;
  _Bool D.4825;
  _Bool D.4826;
  int D.4827;
  _Bool D.4828;
  long int D.4829;
  long int D.4830;
  _Bool D.4833;
  long int D.4834;
  long int D.4835;
  struct MonoLockFreeQueueNode * volatile * D.4840;
  void * D.4841;
  struct MonoLockFreeQueueNode * volatile * D.4844;
  struct MonoLockFreeQueueNode * volatile * D.4847;
  struct MonoThreadHazardPointers * hp;
  struct MonoLockFreeQueueNode * tail;

  hp = mono_hazard_pointer_get ();
  D.4814 = node->next;
  D.4815 = D.4814 != 4294967293B;
  D.4816 = (long int) D.4815;
  D.4817 = __builtin_expect (D.4816, 0);
  if (D.4817 != 0) goto <D.4818>; else goto <D.4819>;
  <D.4818>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 111, "node->next == FREE_NEXT");
  <D.4819>:
  node->next = 4294967294B;
  <D.4762>:
  {
    struct MonoLockFreeQueueNode * next;

    D.4820 = &q->tail;
    tail = get_hazardous_pointer (D.4820, hp, 0);
    mono_memory_read_barrier ();
    next = tail->next;
    mono_memory_read_barrier ();
    D.4821 = q->tail;
    if (D.4821 == tail) goto <D.4822>; else goto <D.4823>;
    <D.4822>:
    D.4824 = next == 4294967295B;
    D.4825 = next == 4294967293B;
    D.4826 = D.4824 | D.4825;
    D.4827 = (int) D.4826;
    D.4828 = D.4827 != 0;
    D.4829 = (long int) D.4828;
    D.4830 = __builtin_expect (D.4829, 0);
    if (D.4830 != 0) goto <D.4831>; else goto <D.4832>;
    <D.4831>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 127, "next != INVALID_NEXT && next != FREE_NEXT");
    <D.4832>:
    D.4833 = next == tail;
    D.4834 = (long int) D.4833;
    D.4835 = __builtin_expect (D.4834, 0);
    if (D.4835 != 0) goto <D.4836>; else goto <D.4837>;
    <D.4836>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 128, "next != tail");
    <D.4837>:
    if (next == 4294967294B) goto <D.4838>; else goto <D.4839>;
    <D.4838>:
    D.4840 = &tail->next;
    D.4841 = InterlockedCompareExchangePointer (D.4840, node, 4294967294B);
    if (D.4841 == 4294967294B) goto <D.4761>; else goto <D.4842>;
    <D.4842>:
    goto <D.4843>;
    <D.4839>:
    D.4844 = &q->tail;
    InterlockedCompareExchangePointer (D.4844, next, tail);
    <D.4843>:
    <D.4823>:
    mono_memory_write_barrier ();
    if (0 != 0) goto <D.4845>; else goto <D.4846>;
    <D.4845>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 147, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.4846>:
    hp->hazard_pointers[0] = 0B;
  }
  goto <D.4762>;
  <D.4761>:
  D.4847 = &q->tail;
  InterlockedCompareExchangePointer (D.4847, node, tail);
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4848>; else goto <D.4849>;
  <D.4848>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 154, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.4849>:
  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.4850;
  unsigned int exch.2;
  unsigned int comp.3;
  unsigned int D.4853;

  exch.2 = (unsigned int) exch;
  comp.3 = (unsigned int) comp;
  D.4853 = __sync_val_compare_and_swap_4 (dest, comp.3, exch.2);
  D.4850 = (void *) D.4853;
  return D.4850;
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_lock_free_queue_dequeue (struct MonoLockFreeQueue * q)
{
  struct MonoLockFreeQueueNode * volatile * D.4855;
  struct MonoLockFreeQueueNode * D.4856;
  _Bool D.4859;
  _Bool D.4860;
  _Bool D.4861;
  int D.4862;
  _Bool D.4863;
  long int D.4864;
  long int D.4865;
  _Bool D.4868;
  long int D.4869;
  long int D.4870;
  int D.4879;
  int D.4882;
  struct MonoLockFreeQueueNode * D.4885;
  struct MonoLockFreeQueueNode * volatile * D.4886;
  _Bool D.4888;
  long int D.4889;
  long int D.4890;
  struct MonoLockFreeQueueNode * volatile * D.4893;
  void * D.4894;
  struct MonoLockFreeQueueNode * D.4900;
  _Bool D.4901;
  long int D.4902;
  long int D.4903;
  int D.4906;
  int D.4909;
  _Bool D.4910;
  long int D.4911;
  long int D.4912;
  int D.4915;
  struct MonoThreadHazardPointers * hp;
  struct MonoLockFreeQueueNode * head;
  void retry = <<< error >>>;

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

    D.4855 = &q->head;
    head = get_hazardous_pointer (D.4855, hp, 0);
    tail = q->tail;
    mono_memory_read_barrier ();
    next = head->next;
    mono_memory_read_barrier ();
    D.4856 = q->head;
    if (D.4856 == head) goto <D.4857>; else goto <D.4858>;
    <D.4857>:
    D.4859 = next == 4294967295B;
    D.4860 = next == 4294967293B;
    D.4861 = D.4859 | D.4860;
    D.4862 = (int) D.4861;
    D.4863 = D.4862 != 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", 229, "next != INVALID_NEXT && next != FREE_NEXT");
    <D.4867>:
    D.4868 = next == head;
    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", 230, "next != head");
    <D.4872>:
    if (head == tail) goto <D.4873>; else goto <D.4874>;
    <D.4873>:
    if (next == 4294967294B) goto <D.4875>; else goto <D.4876>;
    <D.4875>:
    if (0 != 0) goto <D.4877>; else goto <D.4878>;
    <D.4877>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 236, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.4878>:
    hp->hazard_pointers[0] = 0B;
    D.4879 = is_dummy (q, head);
    if (D.4879 == 0) goto <D.4880>; else goto <D.4881>;
    <D.4880>:
    D.4882 = try_reenqueue_dummy (q);
    if (D.4882 != 0) goto <D.4883>; else goto <D.4884>;
    <D.4883>:
    // predicted unlikely by continue predictor.
    goto <D.4792>;
    <D.4884>:
    <D.4881>:
    D.4885 = 0B;
    return D.4885;
    <D.4876>:
    D.4886 = &q->tail;
    InterlockedCompareExchangePointer (D.4886, next, tail);
    goto <D.4887>;
    <D.4874>:
    D.4888 = next == 4294967294B;
    D.4889 = (long int) D.4888;
    D.4890 = __builtin_expect (D.4889, 0);
    if (D.4890 != 0) goto <D.4891>; else goto <D.4892>;
    <D.4891>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 254, "next != END_MARKER");
    <D.4892>:
    D.4893 = &q->head;
    D.4894 = InterlockedCompareExchangePointer (D.4893, next, head);
    if (D.4894 == head) goto <D.4793>; else goto <D.4895>;
    <D.4895>:
    <D.4887>:
    <D.4858>:
    mono_memory_write_barrier ();
    if (0 != 0) goto <D.4896>; else goto <D.4897>;
    <D.4896>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 262, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.4897>:
    hp->hazard_pointers[0] = 0B;
  }
  <D.4792>:
  goto <D.4794>;
  <D.4793>:
  mono_memory_write_barrier ();
  if (0 != 0) goto <D.4898>; else goto <D.4899>;
  <D.4898>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 270, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.4899>:
  hp->hazard_pointers[0] = 0B;
  D.4900 = head->next;
  D.4901 = D.4900 == 0B;
  D.4902 = (long int) D.4901;
  D.4903 = __builtin_expect (D.4902, 0);
  if (D.4903 != 0) goto <D.4904>; else goto <D.4905>;
  <D.4904>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 272, "head->next");
  <D.4905>:
  head->next = 4294967295B;
  D.4906 = is_dummy (q, head);
  if (D.4906 != 0) goto <D.4907>; else goto <D.4908>;
  <D.4907>:
  D.4909 = q->has_dummy;
  D.4910 = D.4909 == 0;
  D.4911 = (long int) D.4910;
  D.4912 = __builtin_expect (D.4911, 0);
  if (D.4912 != 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", 286, "q->has_dummy");
  <D.4914>:
  q->has_dummy = 0;
  mono_memory_write_barrier ();
  mono_thread_hazardous_free_or_queue (head, free_dummy, 0, 1);
  D.4915 = try_reenqueue_dummy (q);
  if (D.4915 != 0) goto retry; else goto <D.4916>;
  <D.4916>:
  D.4885 = 0B;
  return D.4885;
  <D.4908>:
  D.4885 = head;
  return D.4885;
}


free_dummy (void * _dummy)
{
  struct MonoLockFreeQueueNode * D.4918;
  int D.4919;
  _Bool D.4920;
  long int D.4921;
  long int D.4922;
  struct MonoLockFreeQueueDummy * dummy;

  dummy = _dummy;
  D.4918 = &dummy->node;
  mono_lock_free_queue_node_free (D.4918);
  D.4919 = dummy->in_use;
  D.4920 = D.4919 == 0;
  D.4921 = (long int) D.4920;
  D.4922 = __builtin_expect (D.4921, 0);
  if (D.4922 != 0) goto <D.4923>; else goto <D.4924>;
  <D.4923>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "lock-free-queue.c", 162, "dummy->in_use");
  <D.4924>:
  mono_memory_write_barrier ();
  dummy->in_use = 0;
}


is_dummy (struct MonoLockFreeQueue * q, struct MonoLockFreeQueueNode * n)
{
  gboolean D.4925;
  int iftmp.4;
  struct MonoLockFreeQueueNode * D.4929;
  struct MonoLockFreeQueueNode * D.4931;

  D.4929 = &q->dummies[0].node;
  if (D.4929 <= n) goto <D.4930>; else goto <D.4927>;
  <D.4930>:
  D.4931 = &q->dummies[2].node;
  if (D.4931 > n) goto <D.4932>; else goto <D.4927>;
  <D.4932>:
  iftmp.4 = 1;
  goto <D.4928>;
  <D.4927>:
  iftmp.4 = 0;
  <D.4928>:
  D.4925 = iftmp.4;
  return D.4925;
}


try_reenqueue_dummy (struct MonoLockFreeQueue * q)
{
  int D.4934;
  gboolean D.4937;
  volatile gint32 * D.4940;
  int D.4941;
  struct MonoLockFreeQueueNode * D.4944;
  struct MonoLockFreeQueueDummy * dummy;

  D.4934 = q->has_dummy;
  if (D.4934 != 0) goto <D.4935>; else goto <D.4936>;
  <D.4935>:
  D.4937 = 0;
  return D.4937;
  <D.4936>:
  dummy = get_dummy (q);
  if (dummy == 0B) goto <D.4938>; else goto <D.4939>;
  <D.4938>:
  D.4937 = 0;
  return D.4937;
  <D.4939>:
  D.4940 = &q->has_dummy;
  D.4941 = InterlockedCompareExchange (D.4940, 1, 0);
  if (D.4941 != 0) goto <D.4942>; else goto <D.4943>;
  <D.4942>:
  dummy->in_use = 0;
  D.4937 = 0;
  return D.4937;
  <D.4943>:
  D.4944 = &dummy->node;
  mono_lock_free_queue_enqueue (q, D.4944);
  D.4937 = 1;
  return D.4937;
}


get_dummy (struct MonoLockFreeQueue * q)
{
  int D.4946;
  volatile gint32 * D.4949;
  int D.4950;
  struct MonoLockFreeQueueDummy * D.4953;
  int i;

  i = 0;
  goto <D.4774>;
  <D.4773>:
  {
    struct MonoLockFreeQueueDummy * dummy;

    dummy = &q->dummies[i];
    D.4946 = dummy->in_use;
    if (D.4946 != 0) goto <D.4947>; else goto <D.4948>;
    <D.4947>:
    // predicted unlikely by continue predictor.
    goto <D.4772>;
    <D.4948>:
    D.4949 = &dummy->in_use;
    D.4950 = InterlockedCompareExchange (D.4949, 1, 0);
    if (D.4950 == 0) goto <D.4951>; else goto <D.4952>;
    <D.4951>:
    D.4953 = dummy;
    return D.4953;
    <D.4952>:
  }
  <D.4772>:
  i = i + 1;
  <D.4774>:
  if (i <= 1) goto <D.4773>; else goto <D.4775>;
  <D.4775>:
  D.4953 = 0B;
  return D.4953;
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.4955;
  unsigned int exch.5;
  unsigned int comp.6;
  unsigned int D.4958;

  exch.5 = (unsigned int) exch;
  comp.6 = (unsigned int) comp;
  D.4958 = __sync_val_compare_and_swap_4 (dest, comp.6, exch.5);
  D.4955 = (gint32) D.4958;
  return D.4955;
}