sgen_gray_object_alloc_queue_section (struct SgenGrayQueue * queue)
{
  void (*<T2bc4>) (struct SgenGrayQueue *) D.18183;
  struct GrayQueueSection * D.18186;
  struct GrayQueueSection * D.18189;
  struct GrayQueueSection * D.18191;
  struct GrayQueueSection * section;

  D.18183 = queue->alloc_prepare_func;
  if (D.18183 != 0B) goto <D.18184>; else goto <D.18185>;
  <D.18184>:
  D.18183 = queue->alloc_prepare_func;
  D.18183 (queue);
  <D.18185>:
  D.18186 = queue->free_list;
  if (D.18186 != 0B) goto <D.18187>; else goto <D.18188>;
  <D.18187>:
  section = queue->free_list;
  D.18189 = section->next;
  queue->free_list = D.18189;
  goto <D.18190>;
  <D.18188>:
  section = sgen_alloc_internal (14);
  <D.18190>:
  section->end = 0;
  D.18191 = queue->first;
  section->next = D.18191;
  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.18198;
  int D.18200;
  _Bool D.18201;
  long int D.18202;
  long int D.18203;
  int D.18208;
  int D.18209;

  if (0 != 0) goto <D.18192>; else goto <D.18193>;
  <D.18192>:
  monoeg_g_log (0B, 4, "enqueueing a null object");
  <D.18109>:
  goto <D.18109>;
  <D.18193>:
  D.18198 = queue->first;
  if (D.18198 == 0B) goto <D.18195>; else goto <D.18199>;
  <D.18199>:
  D.18198 = queue->first;
  D.18200 = D.18198->end;
  if (D.18200 == 125) goto <D.18195>; else goto <D.18196>;
  <D.18195>:
  iftmp.0 = 1;
  goto <D.18197>;
  <D.18196>:
  iftmp.0 = 0;
  <D.18197>:
  D.18201 = iftmp.0 != 0;
  D.18202 = (long int) D.18201;
  D.18203 = __builtin_expect (D.18202, 0);
  if (D.18203 != 0) goto <D.18204>; else goto <D.18205>;
  <D.18204>:
  sgen_gray_object_alloc_queue_section (queue);
  <D.18205>:
  if (0 != 0) goto <D.18206>; else goto <D.18207>;
  <D.18206>:
  D.18198 = queue->first;
  D.18198 = queue->first;
  D.18200 = D.18198->end;
  monoeg_g_log (0B, 4, "gray queue %p overflow, first %p, end %d", queue, D.18198, D.18200);
  <D.18110>:
  goto <D.18110>;
  <D.18207>:
  D.18198 = queue->first;
  D.18198 = queue->first;
  D.18200 = D.18198->end;
  D.18208 = D.18200;
  D.18209 = D.18208 + 1;
  D.18198->end = D.18209;
  D.18198->objects[D.18208] = obj;
}


sgen_gray_object_dequeue (struct SgenGrayQueue * queue)
{
  int D.18210;
  char * D.18213;
  struct GrayQueueSection * D.18216;
  int D.18217;
  int D.18218;
  _Bool D.18219;
  long int D.18220;
  long int D.18221;
  struct GrayQueueSection * D.18224;
  struct GrayQueueSection * D.18225;
  char * obj;

  D.18210 = sgen_gray_object_queue_is_empty (queue);
  if (D.18210 != 0) goto <D.18211>; else goto <D.18212>;
  <D.18211>:
  D.18213 = 0B;
  return D.18213;
  <D.18212>:
  if (0 != 0) goto <D.18214>; else goto <D.18215>;
  <D.18214>:
  D.18216 = queue->first;
  D.18216 = queue->first;
  D.18217 = D.18216->end;
  monoeg_g_log (0B, 4, "gray queue %p underflow, first %p, end %d", queue, D.18216, D.18217);
  <D.18115>:
  goto <D.18115>;
  <D.18215>:
  D.18216 = queue->first;
  D.18216 = queue->first;
  D.18217 = D.18216->end;
  D.18218 = D.18217 + -1;
  D.18216->end = D.18218;
  D.18217 = D.18216->end;
  obj = D.18216->objects[D.18217];
  D.18216 = queue->first;
  D.18217 = D.18216->end;
  D.18219 = D.18217 == 0;
  D.18220 = (long int) D.18219;
  D.18221 = __builtin_expect (D.18220, 0);
  if (D.18221 != 0) goto <D.18222>; else goto <D.18223>;
  <D.18222>:
  {
    struct GrayQueueSection * section;

    section = queue->first;
    D.18224 = section->next;
    queue->first = D.18224;
    D.18225 = queue->free_list;
    section->next = D.18225;
    queue->free_list = section;
  }
  <D.18223>:
  D.18213 = obj;
  return D.18213;
}


sgen_gray_object_queue_is_empty (struct SgenGrayQueue * queue)
{
  gboolean D.18227;
  struct GrayQueueSection * D.18228;
  _Bool D.18229;

  D.18228 = queue->first;
  D.18229 = D.18228 == 0B;
  D.18227 = (gboolean) D.18229;
  return D.18227;
}


sgen_gray_object_dequeue_section (struct SgenGrayQueue * queue)
{
  struct GrayQueueSection * D.18231;
  struct GrayQueueSection * D.18234;
  struct GrayQueueSection * D.18235;
  struct GrayQueueSection * section;

  D.18231 = queue->first;
  if (D.18231 == 0B) goto <D.18232>; else goto <D.18233>;
  <D.18232>:
  D.18234 = 0B;
  return D.18234;
  <D.18233>:
  section = queue->first;
  D.18235 = section->next;
  queue->first = D.18235;
  section->next = 0B;
  D.18234 = section;
  return D.18234;
}


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

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


sgen_gray_object_queue_init (struct SgenGrayQueue * queue, void (*GrayQueueEnqueueCheckFunc) (char *) enqueue_check_func)
{
  int D.18238;
  _Bool D.18239;
  long int D.18240;
  long int D.18241;
  struct GrayQueueSection * D.18247;
  struct GrayQueueSection * D.18248;
  struct GrayQueueSection * section;
  struct GrayQueueSection * next;
  int i;

  D.18238 = sgen_gray_object_queue_is_empty (queue);
  D.18239 = D.18238 == 0;
  D.18240 = (long int) D.18239;
  D.18241 = __builtin_expect (D.18240, 0);
  if (D.18241 != 0) goto <D.18242>; else goto <D.18243>;
  <D.18242>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 168, "sgen_gray_object_queue_is_empty (queue)");
  <D.18243>:
  queue->alloc_prepare_func = 0B;
  queue->alloc_prepare_data = 0B;
  i = 0;
  section = queue->free_list;
  goto <D.18133>;
  <D.18132>:
  i = i + 1;
  section = section->next;
  <D.18133>:
  if (section != 0B) goto <D.18244>; else goto <D.18134>;
  <D.18244>:
  if (i <= 62) goto <D.18132>; else goto <D.18134>;
  <D.18134>:
  if (section == 0B) goto <D.18245>; else goto <D.18246>;
  <D.18245>:
  return;
  <D.18246>:
  goto <D.18136>;
  <D.18135>:
  next = section->next;
  D.18247 = next->next;
  section->next = D.18247;
  sgen_gray_object_free_queue_section (next);
  <D.18136>:
  D.18248 = section->next;
  if (D.18248 != 0B) goto <D.18135>; else goto <D.18137>;
  <D.18137>:
}


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.18250;
  _Bool D.18251;
  long int D.18252;
  long int D.18253;
  struct GrayQueueSection * D.18256;

  D.18250 = queue->first;
  D.18251 = D.18250 != 0B;
  D.18252 = (long int) D.18251;
  D.18253 = __builtin_expect (D.18252, 0);
  if (D.18253 != 0) goto <D.18254>; else goto <D.18255>;
  <D.18254>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 218, "!queue->first");
  <D.18255>:
  goto <D.18155>;
  <D.18154>:
  {
    struct GrayQueueSection * next;

    D.18256 = queue->free_list;
    next = D.18256->next;
    D.18256 = queue->free_list;
    sgen_gray_object_free_queue_section (D.18256);
    queue->free_list = next;
  }
  <D.18155>:
  D.18256 = queue->free_list;
  if (D.18256 != 0B) goto <D.18154>; else goto <D.18156>;
  <D.18156>:
}


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.18257;
  _Bool D.18258;
  long int D.18259;
  long int D.18260;
  union mono_mutex_t * D.18265;

  D.18257 = sgen_section_gray_queue_is_empty (queue);
  D.18258 = D.18257 == 0;
  D.18259 = (long int) D.18258;
  D.18260 = __builtin_expect (D.18259, 0);
  if (D.18260 != 0) goto <D.18261>; else goto <D.18262>;
  <D.18261>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-gray.c", 255, "sgen_section_gray_queue_is_empty (queue)");
  <D.18262>:
  queue->locked = locked;
  if (locked != 0) goto <D.18263>; else goto <D.18264>;
  <D.18263>:
  D.18265 = &queue->lock;
  mono_mutex_init_recursive (D.18265);
  <D.18264>:
}


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


sgen_section_gray_queue_is_empty (struct SgenSectionGrayQueue * queue)
{
  gboolean D.18269;
  struct GrayQueueSection * D.18270;
  _Bool D.18271;

  D.18270 = queue->first;
  D.18271 = D.18270 == 0B;
  D.18269 = (gboolean) D.18271;
  return D.18269;
}


sgen_section_gray_queue_dequeue (struct SgenSectionGrayQueue * queue)
{
  struct GrayQueueSection * D.18273;
  struct GrayQueueSection * D.18276;
  struct GrayQueueSection * D.18278;
  struct GrayQueueSection * section;

  lock_section_queue (queue);
  D.18273 = queue->first;
  if (D.18273 != 0B) goto <D.18274>; else goto <D.18275>;
  <D.18274>:
  section = queue->first;
  D.18276 = section->next;
  queue->first = D.18276;
  section->next = 0B;
  goto <D.18277>;
  <D.18275>:
  section = 0B;
  <D.18277>:
  unlock_section_queue (queue);
  D.18278 = section;
  return D.18278;
}


lock_section_queue (struct SgenSectionGrayQueue * queue)
{
  int D.18280;
  union mono_mutex_t * D.18283;

  D.18280 = queue->locked;
  if (D.18280 == 0) goto <D.18281>; else goto <D.18282>;
  <D.18281>:
  return;
  <D.18282>:
  D.18283 = &queue->lock;
  pthread_mutex_lock (D.18283);
}


unlock_section_queue (struct SgenSectionGrayQueue * queue)
{
  int D.18285;
  union mono_mutex_t * D.18288;

  D.18285 = queue->locked;
  if (D.18285 == 0) goto <D.18286>; else goto <D.18287>;
  <D.18286>:
  return;
  <D.18287>:
  D.18288 = &queue->lock;
  pthread_mutex_unlock (D.18288);
}


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

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