sgen_gray_object_alloc_queue_section (struct SgenGrayQueue * queue)
{
  void (*<T2b3c>) (struct SgenGrayQueue *) D.17653;
  struct GrayQueueSection * D.17656;
  struct GrayQueueSection * D.17659;
  struct GrayQueueSection * D.17661;
  struct GrayQueueSection * section;

  D.17653 = queue->alloc_prepare_func;
  if (D.17653 != 0B) goto <D.17654>; else goto <D.17655>;
  <D.17654>:
  D.17653 = queue->alloc_prepare_func;
  D.17653 (queue);
  <D.17655>:
  D.17656 = queue->free_list;
  if (D.17656 != 0B) goto <D.17657>; else goto <D.17658>;
  <D.17657>:
  section = queue->free_list;
  D.17659 = section->next;
  queue->free_list = D.17659;
  goto <D.17660>;
  <D.17658>:
  section = sgen_alloc_internal (14);
  <D.17660>:
  section->end = 0;
  D.17661 = queue->first;
  section->next = D.17661;
  queue->first = section;
}


sgen_gray_object_free_queue_section (struct GrayQueueSection * section)
{
  sgen_free_internal (section, 14);
}


sgen_gray_object_enqueue (struct SgenGrayQueue * queue, char * obj)
{
  int iftmp.0;
  struct GrayQueueSection * D.17668;
  int D.17670;
  _Bool D.17671;
  long int D.17672;
  long int D.17673;
  int D.17678;
  int D.17679;

  if (0 != 0) goto <D.17662>; else goto <D.17663>;
  <D.17662>:
  monoeg_g_log (0B, 4, "enqueueing a null object");
  <D.17579>:
  goto <D.17579>;
  <D.17663>:
  D.17668 = queue->first;
  if (D.17668 == 0B) goto <D.17665>; else goto <D.17669>;
  <D.17669>:
  D.17668 = queue->first;
  D.17670 = D.17668->end;
  if (D.17670 == 125) goto <D.17665>; else goto <D.17666>;
  <D.17665>:
  iftmp.0 = 1;
  goto <D.17667>;
  <D.17666>:
  iftmp.0 = 0;
  <D.17667>:
  D.17671 = iftmp.0 != 0;
  D.17672 = (long int) D.17671;
  D.17673 = __builtin_expect (D.17672, 0);
  if (D.17673 != 0) goto <D.17674>; else goto <D.17675>;
  <D.17674>:
  sgen_gray_object_alloc_queue_section (queue);
  <D.17675>:
  if (0 != 0) goto <D.17676>; else goto <D.17677>;
  <D.17676>:
  D.17668 = queue->first;
  D.17670 = D.17668->end;
  D.17668 = queue->first;
  monoeg_g_log (0B, 4, "gray queue %p overflow, first %p, end %d", queue, D.17668, D.17670);
  <D.17580>:
  goto <D.17580>;
  <D.17677>:
  D.17668 = queue->first;
  D.17668 = queue->first;
  D.17670 = D.17668->end;
  D.17678 = D.17670;
  D.17679 = D.17678 + 1;
  D.17668->end = D.17679;
  D.17668->objects[D.17678] = obj;
}


sgen_gray_object_dequeue (struct SgenGrayQueue * queue)
{
  int D.17680;
  char * D.17683;
  struct GrayQueueSection * D.17686;
  int D.17687;
  int D.17688;
  _Bool D.17689;
  long int D.17690;
  long int D.17691;
  struct GrayQueueSection * D.17694;
  struct GrayQueueSection * D.17695;
  char * obj;

  D.17680 = sgen_gray_object_queue_is_empty (queue);
  if (D.17680 != 0) goto <D.17681>; else goto <D.17682>;
  <D.17681>:
  D.17683 = 0B;
  return D.17683;
  <D.17682>:
  if (0 != 0) goto <D.17684>; else goto <D.17685>;
  <D.17684>:
  D.17686 = queue->first;
  D.17687 = D.17686->end;
  D.17686 = queue->first;
  monoeg_g_log (0B, 4, "gray queue %p underflow, first %p, end %d", queue, D.17686, D.17687);
  <D.17585>:
  goto <D.17585>;
  <D.17685>:
  D.17686 = queue->first;
  D.17686 = queue->first;
  D.17687 = D.17686->end;
  D.17688 = D.17687 + -1;
  D.17686->end = D.17688;
  D.17687 = D.17686->end;
  obj = D.17686->objects[D.17687];
  D.17686 = queue->first;
  D.17687 = D.17686->end;
  D.17689 = D.17687 == 0;
  D.17690 = (long int) D.17689;
  D.17691 = __builtin_expect (D.17690, 0);
  if (D.17691 != 0) goto <D.17692>; else goto <D.17693>;
  <D.17692>:
  {
    struct GrayQueueSection * section;

    section = queue->first;
    D.17694 = section->next;
    queue->first = D.17694;
    D.17695 = queue->free_list;
    section->next = D.17695;
    queue->free_list = section;
  }
  <D.17693>:
  D.17683 = obj;
  return D.17683;
}


sgen_gray_object_queue_is_empty (struct SgenGrayQueue * queue)
{
  gboolean D.17697;
  struct GrayQueueSection * D.17698;
  _Bool D.17699;

  D.17698 = queue->first;
  D.17699 = D.17698 == 0B;
  D.17697 = (gboolean) D.17699;
  return D.17697;
}


sgen_gray_object_dequeue_section (struct SgenGrayQueue * queue)
{
  struct GrayQueueSection * D.17701;
  struct GrayQueueSection * D.17704;
  struct GrayQueueSection * D.17705;
  struct GrayQueueSection * section;

  D.17701 = queue->first;
  if (D.17701 == 0B) goto <D.17702>; else goto <D.17703>;
  <D.17702>:
  D.17704 = 0B;
  return D.17704;
  <D.17703>:
  section = queue->first;
  D.17705 = section->next;
  queue->first = D.17705;
  section->next = 0B;
  D.17704 = section;
  return D.17704;
}


sgen_gray_object_enqueue_section (struct SgenGrayQueue * queue, struct GrayQueueSection * section)
{
  struct GrayQueueSection * D.17707;

  D.17707 = queue->first;
  section->next = D.17707;
  queue->first = section;
}


sgen_gray_object_queue_init (struct SgenGrayQueue * queue, void (*GrayQueueEnqueueCheckFunc) (char *) enqueue_check_func)
{
  int D.17708;
  _Bool D.17709;
  long int D.17710;
  long int D.17711;
  _Bool D.17714;
  _Bool D.17715;
  _Bool D.17716;
  struct GrayQueueSection * D.17719;
  struct GrayQueueSection * D.17720;
  struct GrayQueueSection * section;
  struct GrayQueueSection * next;
  int i;

  D.17708 = sgen_gray_object_queue_is_empty (queue);
  D.17709 = D.17708 == 0;
  D.17710 = (long int) D.17709;
  D.17711 = __builtin_expect (D.17710, 0);
  if (D.17711 != 0) goto <D.17712>; else goto <D.17713>;
  <D.17712>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 168, "sgen_gray_object_queue_is_empty (queue)");
  <D.17713>:
  queue->alloc_prepare_func = 0B;
  queue->alloc_prepare_data = 0B;
  i = 0;
  section = queue->free_list;
  goto <D.17603>;
  <D.17602>:
  i = i + 1;
  section = section->next;
  <D.17603>:
  D.17714 = section != 0B;
  D.17715 = i <= 62;
  D.17716 = D.17714 & D.17715;
  if (D.17716 != 0) goto <D.17602>; else goto <D.17604>;
  <D.17604>:
  if (section == 0B) goto <D.17717>; else goto <D.17718>;
  <D.17717>:
  return;
  <D.17718>:
  goto <D.17606>;
  <D.17605>:
  next = section->next;
  D.17719 = next->next;
  section->next = D.17719;
  sgen_gray_object_free_queue_section (next);
  <D.17606>:
  D.17720 = section->next;
  if (D.17720 != 0B) goto <D.17605>; else goto <D.17607>;
  <D.17607>:
}


sgen_gray_object_queue_init_invalid (struct SgenGrayQueue * queue)
{
  sgen_gray_object_queue_init (queue, 0B);
  queue->alloc_prepare_func = invalid_prepare_func;
  queue->alloc_prepare_data = 0B;
}


invalid_prepare_func (struct SgenGrayQueue * queue)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-gray.c", 195);
}


sgen_gray_object_queue_init_with_alloc_prepare (struct SgenGrayQueue * queue, void (*GrayQueueEnqueueCheckFunc) (char *) enqueue_check_func, void (*GrayQueueAllocPrepareFunc) (struct SgenGrayQueue *) alloc_prepare_func, void * data)
{
  sgen_gray_object_queue_init (queue, enqueue_check_func);
  queue->alloc_prepare_func = alloc_prepare_func;
  queue->alloc_prepare_data = data;
}


sgen_gray_object_queue_deinit (struct SgenGrayQueue * queue)
{
  struct GrayQueueSection * D.17722;
  _Bool D.17723;
  long int D.17724;
  long int D.17725;
  struct GrayQueueSection * D.17728;

  D.17722 = queue->first;
  D.17723 = D.17722 != 0B;
  D.17724 = (long int) D.17723;
  D.17725 = __builtin_expect (D.17724, 0);
  if (D.17725 != 0) goto <D.17726>; else goto <D.17727>;
  <D.17726>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 218, "!queue->first");
  <D.17727>:
  goto <D.17625>;
  <D.17624>:
  {
    struct GrayQueueSection * next;

    D.17728 = queue->free_list;
    next = D.17728->next;
    D.17728 = queue->free_list;
    sgen_gray_object_free_queue_section (D.17728);
    queue->free_list = next;
  }
  <D.17625>:
  D.17728 = queue->free_list;
  if (D.17728 != 0B) goto <D.17624>; else goto <D.17626>;
  <D.17626>:
}


sgen_gray_object_queue_disable_alloc_prepare (struct SgenGrayQueue * queue)
{
  queue->alloc_prepare_func = 0B;
  queue->alloc_prepare_data = 0B;
}


sgen_section_gray_queue_init (struct SgenSectionGrayQueue * queue, gboolean locked, void (*GrayQueueEnqueueCheckFunc) (char *) enqueue_check_func)
{
  int D.17729;
  _Bool D.17730;
  long int D.17731;
  long int D.17732;
  union mono_mutex_t * D.17737;

  D.17729 = sgen_section_gray_queue_is_empty (queue);
  D.17730 = D.17729 == 0;
  D.17731 = (long int) D.17730;
  D.17732 = __builtin_expect (D.17731, 0);
  if (D.17732 != 0) goto <D.17733>; else goto <D.17734>;
  <D.17733>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 255, "sgen_section_gray_queue_is_empty (queue)");
  <D.17734>:
  queue->locked = locked;
  if (locked != 0) goto <D.17735>; else goto <D.17736>;
  <D.17735>:
  D.17737 = &queue->lock;
  mono_mutex_init_recursive (D.17737);
  <D.17736>:
}


mono_mutex_init_recursive (union mono_mutex_t * mutex)
{
  int D.17738;
  int res;
  union pthread_mutexattr_t attr;

  try
    {
      pthread_mutexattr_init (&attr);
      pthread_mutexattr_settype (&attr, 1);
      res = pthread_mutex_init (mutex, &attr);
      pthread_mutexattr_destroy (&attr);
      D.17738 = res;
      return D.17738;
    }
  finally
    {
      attr = {CLOBBER};
    }
}


sgen_section_gray_queue_is_empty (struct SgenSectionGrayQueue * queue)
{
  gboolean D.17741;
  struct GrayQueueSection * D.17742;
  _Bool D.17743;

  D.17742 = queue->first;
  D.17743 = D.17742 == 0B;
  D.17741 = (gboolean) D.17743;
  return D.17741;
}


sgen_section_gray_queue_dequeue (struct SgenSectionGrayQueue * queue)
{
  struct GrayQueueSection * D.17745;
  struct GrayQueueSection * D.17748;
  struct GrayQueueSection * D.17750;
  struct GrayQueueSection * section;

  lock_section_queue (queue);
  D.17745 = queue->first;
  if (D.17745 != 0B) goto <D.17746>; else goto <D.17747>;
  <D.17746>:
  section = queue->first;
  D.17748 = section->next;
  queue->first = D.17748;
  section->next = 0B;
  goto <D.17749>;
  <D.17747>:
  section = 0B;
  <D.17749>:
  unlock_section_queue (queue);
  D.17750 = section;
  return D.17750;
}


lock_section_queue (struct SgenSectionGrayQueue * queue)
{
  int D.17752;
  union mono_mutex_t * D.17755;

  D.17752 = queue->locked;
  if (D.17752 == 0) goto <D.17753>; else goto <D.17754>;
  <D.17753>:
  return;
  <D.17754>:
  D.17755 = &queue->lock;
  pthread_mutex_lock (D.17755);
}


unlock_section_queue (struct SgenSectionGrayQueue * queue)
{
  int D.17757;
  union mono_mutex_t * D.17760;

  D.17757 = queue->locked;
  if (D.17757 == 0) goto <D.17758>; else goto <D.17759>;
  <D.17758>:
  return;
  <D.17759>:
  D.17760 = &queue->lock;
  pthread_mutex_unlock (D.17760);
}


sgen_section_gray_queue_enqueue (struct SgenSectionGrayQueue * queue, struct GrayQueueSection * section)
{
  struct GrayQueueSection * D.17762;

  lock_section_queue (queue);
  D.17762 = queue->first;
  section->next = D.17762;
  queue->first = section;
  unlock_section_queue (queue);
}