sgen_gray_object_alloc_queue_section (struct SgenGrayQueue * queue)
{
  void (*<T34fb>) (struct SgenGrayQueue *) D.19855;
  struct GrayQueueSection * D.19858;
  struct GrayQueueSection * D.19861;
  struct GrayQueueSection * D.19863;
  struct GrayQueueSection * section;

  D.19855 = queue->alloc_prepare_func;
  if (D.19855 != 0B) goto <D.19856>; else goto <D.19857>;
  <D.19856>:
  D.19855 = queue->alloc_prepare_func;
  D.19855 (queue);
  <D.19857>:
  D.19858 = queue->free_list;
  if (D.19858 != 0B) goto <D.19859>; else goto <D.19860>;
  <D.19859>:
  section = queue->free_list;
  D.19861 = section->next;
  queue->free_list = D.19861;
  goto <D.19862>;
  <D.19860>:
  section = sgen_alloc_internal (14);
  <D.19862>:
  section->end = 0;
  D.19863 = queue->first;
  section->next = D.19863;
  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.19870;
  int D.19872;
  _Bool D.19873;
  long int D.19874;
  long int D.19875;
  int D.19880;
  int D.19881;

  if (0 != 0) goto <D.19864>; else goto <D.19865>;
  <D.19864>:
  monoeg_g_log (0B, 4, "enqueueing a null object");
  <D.19779>:
  goto <D.19779>;
  <D.19865>:
  D.19870 = queue->first;
  if (D.19870 == 0B) goto <D.19867>; else goto <D.19871>;
  <D.19871>:
  D.19870 = queue->first;
  D.19872 = D.19870->end;
  if (D.19872 == 125) goto <D.19867>; else goto <D.19868>;
  <D.19867>:
  iftmp.0 = 1;
  goto <D.19869>;
  <D.19868>:
  iftmp.0 = 0;
  <D.19869>:
  D.19873 = iftmp.0 != 0;
  D.19874 = (long int) D.19873;
  D.19875 = __builtin_expect (D.19874, 0);
  if (D.19875 != 0) goto <D.19876>; else goto <D.19877>;
  <D.19876>:
  sgen_gray_object_alloc_queue_section (queue);
  <D.19877>:
  if (0 != 0) goto <D.19878>; else goto <D.19879>;
  <D.19878>:
  D.19870 = queue->first;
  D.19870 = queue->first;
  D.19872 = D.19870->end;
  monoeg_g_log (0B, 4, "gray queue %p overflow, first %p, end %d", queue, D.19870, D.19872);
  <D.19780>:
  goto <D.19780>;
  <D.19879>:
  D.19870 = queue->first;
  D.19870 = queue->first;
  D.19872 = D.19870->end;
  D.19880 = D.19872;
  D.19881 = D.19880 + 1;
  D.19870->end = D.19881;
  D.19870->objects[D.19880] = obj;
}


sgen_gray_object_dequeue (struct SgenGrayQueue * queue)
{
  int D.19882;
  char * D.19885;
  struct GrayQueueSection * D.19888;
  int D.19889;
  int D.19890;
  _Bool D.19891;
  long int D.19892;
  long int D.19893;
  struct GrayQueueSection * D.19896;
  struct GrayQueueSection * D.19897;
  char * obj;

  D.19882 = sgen_gray_object_queue_is_empty (queue);
  if (D.19882 != 0) goto <D.19883>; else goto <D.19884>;
  <D.19883>:
  D.19885 = 0B;
  return D.19885;
  <D.19884>:
  if (0 != 0) goto <D.19886>; else goto <D.19887>;
  <D.19886>:
  D.19888 = queue->first;
  D.19888 = queue->first;
  D.19889 = D.19888->end;
  monoeg_g_log (0B, 4, "gray queue %p underflow, first %p, end %d", queue, D.19888, D.19889);
  <D.19785>:
  goto <D.19785>;
  <D.19887>:
  D.19888 = queue->first;
  D.19888 = queue->first;
  D.19889 = D.19888->end;
  D.19890 = D.19889 + -1;
  D.19888->end = D.19890;
  D.19889 = D.19888->end;
  obj = D.19888->objects[D.19889];
  D.19888 = queue->first;
  D.19889 = D.19888->end;
  D.19891 = D.19889 == 0;
  D.19892 = (long int) D.19891;
  D.19893 = __builtin_expect (D.19892, 0);
  if (D.19893 != 0) goto <D.19894>; else goto <D.19895>;
  <D.19894>:
  {
    struct GrayQueueSection * section;

    section = queue->first;
    D.19896 = section->next;
    queue->first = D.19896;
    D.19897 = queue->free_list;
    section->next = D.19897;
    queue->free_list = section;
  }
  <D.19895>:
  D.19885 = obj;
  return D.19885;
}


sgen_gray_object_queue_is_empty (struct SgenGrayQueue * queue)
{
  gboolean D.19899;
  struct GrayQueueSection * D.19900;
  _Bool D.19901;

  D.19900 = queue->first;
  D.19901 = D.19900 == 0B;
  D.19899 = (gboolean) D.19901;
  return D.19899;
}


sgen_gray_object_dequeue_section (struct SgenGrayQueue * queue)
{
  struct GrayQueueSection * D.19903;
  struct GrayQueueSection * D.19906;
  struct GrayQueueSection * D.19907;
  struct GrayQueueSection * section;

  D.19903 = queue->first;
  if (D.19903 == 0B) goto <D.19904>; else goto <D.19905>;
  <D.19904>:
  D.19906 = 0B;
  return D.19906;
  <D.19905>:
  section = queue->first;
  D.19907 = section->next;
  queue->first = D.19907;
  section->next = 0B;
  D.19906 = section;
  return D.19906;
}


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

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


sgen_gray_object_queue_init (struct SgenGrayQueue * queue, void (*GrayQueueEnqueueCheckFunc) (char *) enqueue_check_func)
{
  int D.19910;
  _Bool D.19911;
  long int D.19912;
  long int D.19913;
  _Bool D.19916;
  _Bool D.19917;
  _Bool D.19918;
  struct GrayQueueSection * D.19921;
  struct GrayQueueSection * D.19922;
  struct GrayQueueSection * section;
  struct GrayQueueSection * next;
  int i;

  D.19910 = sgen_gray_object_queue_is_empty (queue);
  D.19911 = D.19910 == 0;
  D.19912 = (long int) D.19911;
  D.19913 = __builtin_expect (D.19912, 0);
  if (D.19913 != 0) goto <D.19914>; else goto <D.19915>;
  <D.19914>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 168, "sgen_gray_object_queue_is_empty (queue)");
  <D.19915>:
  queue->alloc_prepare_func = 0B;
  queue->alloc_prepare_data = 0B;
  i = 0;
  section = queue->free_list;
  goto <D.19803>;
  <D.19802>:
  i = i + 1;
  section = section->next;
  <D.19803>:
  D.19916 = section != 0B;
  D.19917 = i <= 62;
  D.19918 = D.19916 & D.19917;
  if (D.19918 != 0) goto <D.19802>; else goto <D.19804>;
  <D.19804>:
  if (section == 0B) goto <D.19919>; else goto <D.19920>;
  <D.19919>:
  return;
  <D.19920>:
  goto <D.19806>;
  <D.19805>:
  next = section->next;
  D.19921 = next->next;
  section->next = D.19921;
  sgen_gray_object_free_queue_section (next);
  <D.19806>:
  D.19922 = section->next;
  if (D.19922 != 0B) goto <D.19805>; else goto <D.19807>;
  <D.19807>:
}


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.19924;
  _Bool D.19925;
  long int D.19926;
  long int D.19927;
  struct GrayQueueSection * D.19930;

  D.19924 = queue->first;
  D.19925 = D.19924 != 0B;
  D.19926 = (long int) D.19925;
  D.19927 = __builtin_expect (D.19926, 0);
  if (D.19927 != 0) goto <D.19928>; else goto <D.19929>;
  <D.19928>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 218, "!queue->first");
  <D.19929>:
  goto <D.19825>;
  <D.19824>:
  {
    struct GrayQueueSection * next;

    D.19930 = queue->free_list;
    next = D.19930->next;
    D.19930 = queue->free_list;
    sgen_gray_object_free_queue_section (D.19930);
    queue->free_list = next;
  }
  <D.19825>:
  D.19930 = queue->free_list;
  if (D.19930 != 0B) goto <D.19824>; else goto <D.19826>;
  <D.19826>:
}


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.19931;
  _Bool D.19932;
  long int D.19933;
  long int D.19934;
  union mono_mutex_t * D.19939;

  D.19931 = sgen_section_gray_queue_is_empty (queue);
  D.19932 = D.19931 == 0;
  D.19933 = (long int) D.19932;
  D.19934 = __builtin_expect (D.19933, 0);
  if (D.19934 != 0) goto <D.19935>; else goto <D.19936>;
  <D.19935>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 255, "sgen_section_gray_queue_is_empty (queue)");
  <D.19936>:
  queue->locked = locked;
  if (locked != 0) goto <D.19937>; else goto <D.19938>;
  <D.19937>:
  D.19939 = &queue->lock;
  mono_mutex_init_recursive (D.19939);
  <D.19938>:
}


mono_mutex_init_recursive (union mono_mutex_t * mutex)
{
  int D.19940;
  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.19940 = res;
      return D.19940;
    }
  finally
    {
      attr = {CLOBBER};
    }
}


sgen_section_gray_queue_is_empty (struct SgenSectionGrayQueue * queue)
{
  gboolean D.19943;
  struct GrayQueueSection * D.19944;
  _Bool D.19945;

  D.19944 = queue->first;
  D.19945 = D.19944 == 0B;
  D.19943 = (gboolean) D.19945;
  return D.19943;
}


sgen_section_gray_queue_dequeue (struct SgenSectionGrayQueue * queue)
{
  struct GrayQueueSection * D.19947;
  struct GrayQueueSection * D.19950;
  struct GrayQueueSection * D.19952;
  struct GrayQueueSection * section;

  lock_section_queue (queue);
  D.19947 = queue->first;
  if (D.19947 != 0B) goto <D.19948>; else goto <D.19949>;
  <D.19948>:
  section = queue->first;
  D.19950 = section->next;
  queue->first = D.19950;
  section->next = 0B;
  goto <D.19951>;
  <D.19949>:
  section = 0B;
  <D.19951>:
  unlock_section_queue (queue);
  D.19952 = section;
  return D.19952;
}


lock_section_queue (struct SgenSectionGrayQueue * queue)
{
  int D.19954;
  union mono_mutex_t * D.19957;

  D.19954 = queue->locked;
  if (D.19954 == 0) goto <D.19955>; else goto <D.19956>;
  <D.19955>:
  return;
  <D.19956>:
  D.19957 = &queue->lock;
  pthread_mutex_lock (D.19957);
}


unlock_section_queue (struct SgenSectionGrayQueue * queue)
{
  int D.19959;
  union mono_mutex_t * D.19962;

  D.19959 = queue->locked;
  if (D.19959 == 0) goto <D.19960>; else goto <D.19961>;
  <D.19960>:
  return;
  <D.19961>:
  D.19962 = &queue->lock;
  pthread_mutex_unlock (D.19962);
}


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

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