mono_gc_wait_for_bridge_processing ()
{
  int bridge_processing_in_progress.0;

  bridge_processing_in_progress.0 = bridge_processing_in_progress;
  if (bridge_processing_in_progress.0 == 0) goto <D.18617>; else goto <D.18618>;
  <D.18617>:
  return;
  <D.18618>:
  mono_trace (64, 8, "GC_BRIDGE waiting for bridge processing to finish");
  sgen_gc_lock ();
  sgen_gc_unlock ();
}


mono_gc_register_bridge_callbacks (struct MonoGCBridgeCallbacks * callbacks)
{
  int D.18620;

  D.18620 = callbacks->bridge_version;
  if (D.18620 != 3) goto <D.18621>; else goto <D.18622>;
  <D.18621>:
  D.18620 = callbacks->bridge_version;
  monoeg_g_log (0B, 4, "Invalid bridge callback version. Expected %d but got %d\n", 3, D.18620);
  <D.18202>:
  goto <D.18202>;
  <D.18622>:
  bridge_callbacks = *callbacks;
}


sgen_is_bridge_object (struct MonoObject * obj)
{
  struct MonoVTable * D.18623;
  <unnamed-unsigned:4> D.18624;
  int D.18625;
  int D.18626;
  gboolean D.18629;
  mono_bool (*<T2f6a>) (struct MonoObject *) D.18630;

  D.18623 = obj->vtable;
  D.18624 = D.18623->gc_bits;
  D.18625 = (int) D.18624;
  D.18626 = D.18625 & 1;
  if (D.18626 == 0) goto <D.18627>; else goto <D.18628>;
  <D.18627>:
  D.18629 = 0;
  return D.18629;
  <D.18628>:
  D.18630 = bridge_callbacks.is_bridge_object;
  D.18629 = D.18630 (obj);
  return D.18629;
}


sgen_is_bridge_class (struct MonoClass * class)
{
  gboolean D.18632;
  mono_bool (*<T2f66>) (struct MonoClass *) D.18633;

  D.18633 = bridge_callbacks.is_bridge_class;
  D.18632 = D.18633 (class);
  return D.18632;
}


sgen_need_bridge_processing ()
{
  gboolean D.18635;
  void (*<T2f74>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.18636;
  _Bool D.18637;

  D.18636 = bridge_callbacks.cross_references;
  D.18637 = D.18636 != 0B;
  D.18635 = (gboolean) D.18637;
  return D.18635;
}


sgen_bridge_register_finalized_object (struct MonoObject * obj)
{
  int D.18639;
  _Bool D.18640;
  long int D.18641;
  long int D.18642;

  D.18639 = sgen_need_bridge_processing ();
  D.18640 = D.18639 == 0;
  D.18641 = (long int) D.18640;
  D.18642 = __builtin_expect (D.18641, 0);
  if (D.18642 != 0) goto <D.18643>; else goto <D.18644>;
  <D.18643>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 537, "sgen_need_bridge_processing ()");
  <D.18644>:
  dyn_array_ptr_add (&registered_bridges, obj);
}


dyn_array_ptr_add (struct DynArray * da, void * ptr)
{
  void * * p;

  p = dyn_array_add (da);
  *p = ptr;
}


dyn_array_add (struct DynArray * da)
{
  int D.18645;
  int D.18646;
  char * D.18647;
  int D.18648;
  int D.18649;
  sizetype D.18650;
  void * D.18651;
  void * p;

  D.18645 = da->size;
  D.18646 = D.18645 + 1;
  dyn_array_ensure_capacity (da, D.18646);
  D.18647 = da->data;
  D.18645 = da->size;
  D.18648 = da->elem_size;
  D.18649 = D.18645 * D.18648;
  D.18650 = (sizetype) D.18649;
  p = D.18647 + D.18650;
  D.18645 = da->size;
  D.18646 = D.18645 + 1;
  da->size = D.18646;
  D.18651 = p;
  return D.18651;
}


dyn_array_ensure_capacity (struct DynArray * da, int capacity)
{
  int D.18655;
  int D.18658;
  int D.18659;
  int D.18660;
  long unsigned int D.18661;
  char * D.18662;
  int D.18663;
  int D.18664;
  long unsigned int D.18665;
  int D.18666;
  long unsigned int D.18667;
  int old_capacity;
  char * new_data;

  old_capacity = da->capacity;
  if (capacity <= old_capacity) goto <D.18653>; else goto <D.18654>;
  <D.18653>:
  return;
  <D.18654>:
  D.18655 = da->capacity;
  if (D.18655 == 0) goto <D.18656>; else goto <D.18657>;
  <D.18656>:
  da->capacity = 2;
  <D.18657>:
  goto <D.18125>;
  <D.18124>:
  D.18655 = da->capacity;
  D.18658 = D.18655 * 2;
  da->capacity = D.18658;
  <D.18125>:
  D.18655 = da->capacity;
  if (D.18655 < capacity) goto <D.18124>; else goto <D.18126>;
  <D.18126>:
  D.18659 = da->elem_size;
  D.18655 = da->capacity;
  D.18660 = D.18659 * D.18655;
  D.18661 = (long unsigned int) D.18660;
  new_data = sgen_alloc_internal_dynamic (D.18661, 21, 1);
  D.18662 = da->data;
  D.18659 = da->elem_size;
  D.18663 = da->size;
  D.18664 = D.18659 * D.18663;
  D.18665 = (long unsigned int) D.18664;
  memcpy (new_data, D.18662, D.18665);
  D.18662 = da->data;
  D.18659 = da->elem_size;
  D.18666 = D.18659 * old_capacity;
  D.18667 = (long unsigned int) D.18666;
  sgen_free_internal_dynamic (D.18662, D.18667, 21);
  da->data = new_data;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.18669;
  long unsigned int D.18670;

  D.18670 = __builtin_object_size (__dest, 0);
  D.18669 = __builtin___memcpy_chk (__dest, __src, __len, D.18670);
  return D.18669;
}


sgen_bridge_reset_data ()
{
  registered_bridges.size = 0;
}


sgen_bridge_processing_stw_step ()
{
  int D.18672;
  char * D.18675;
  long unsigned int D.18676;
  long unsigned int D.18677;
  void * * D.18678;
  void * D.18679;
  struct HashEntry * D.18680;
  long int D.18681;
  long int D.18682;
  int D.18683;
  long unsigned int step_2.1;
  int i;
  gint64 atv;
  gint64 btv;

  D.18672 = registered_bridges.size;
  if (D.18672 == 0) goto <D.18673>; else goto <D.18674>;
  <D.18673>:
  return;
  <D.18674>:
  bridge_processing_in_progress = 1;
  btv = mono_100ns_ticks ();
  dyn_array_ptr_init (&dfs_stack);
  dyn_array_int_init (&merge_array);
  current_time = 0;
  i = 0;
  goto <D.18420>;
  <D.18419>:
  D.18675 = registered_bridges.data;
  D.18676 = (long unsigned int) i;
  D.18677 = D.18676 * 8;
  D.18678 = D.18675 + D.18677;
  D.18679 = *D.18678;
  register_bridge_object (D.18679);
  i = i + 1;
  <D.18420>:
  D.18672 = registered_bridges.size;
  if (D.18672 > i) goto <D.18419>; else goto <D.18421>;
  <D.18421>:
  i = 0;
  goto <D.18423>;
  <D.18422>:
  D.18675 = registered_bridges.data;
  D.18676 = (long unsigned int) i;
  D.18677 = D.18676 * 8;
  D.18678 = D.18675 + D.18677;
  D.18679 = *D.18678;
  D.18680 = get_hash_entry (D.18679, 0B);
  dfs1 (D.18680, 0B);
  i = i + 1;
  <D.18423>:
  D.18672 = registered_bridges.size;
  if (D.18672 > i) goto <D.18422>; else goto <D.18424>;
  <D.18424>:
  atv = mono_100ns_ticks ();
  D.18681 = atv - btv;
  D.18682 = D.18681 / 10;
  D.18683 = (int) D.18682;
  step_2.1 = (long unsigned int) D.18683;
  step_2 = step_2.1;
}


dyn_array_ptr_init (struct DynArray * da)
{
  dyn_array_init (da, 8);
}


dyn_array_init (struct DynArray * da, int elem_size)
{
  da->size = 0;
  da->elem_size = elem_size;
  da->capacity = 0;
  da->data = 0B;
}


dyn_array_int_init (struct DynArray * da)
{
  dyn_array_init (da, 4);
}


register_bridge_object (struct MonoObject * obj)
{
  struct HashEntry * D.18686;
  struct HashEntry * entry;

  entry = get_hash_entry (obj, 0B);
  entry->is_bridge = 1;
  D.18686 = entry;
  return D.18686;
}


get_hash_entry (struct MonoObject * obj, gboolean * existing)
{
  struct HashEntry * D.18692;
  struct HashEntry * entry;
  struct HashEntry new_entry;

  try
    {
      entry = sgen_hash_table_lookup (&hash_table, obj);
      if (entry != 0B) goto <D.18688>; else goto <D.18689>;
      <D.18688>:
      if (existing != 0B) goto <D.18690>; else goto <D.18691>;
      <D.18690>:
      *existing = 1;
      <D.18691>:
      D.18692 = entry;
      return D.18692;
      <D.18689>:
      if (existing != 0B) goto <D.18693>; else goto <D.18694>;
      <D.18693>:
      *existing = 0;
      <D.18694>:
      memset (&new_entry, 0, 56);
      new_entry.obj = obj;
      dyn_array_ptr_init (&new_entry.srcs);
      new_entry.finishing_time = -1;
      new_entry.scc_index = -1;
      sgen_hash_table_replace (&hash_table, obj, &new_entry, 0B);
      D.18692 = sgen_hash_table_lookup (&hash_table, obj);
      return D.18692;
    }
  finally
    {
      new_entry = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.18699;
  int D.18704;
  void * D.18706;
  long unsigned int D.18707;

  D.18699 = __builtin_constant_p (__len);
  if (D.18699 != 0) goto <D.18700>; else goto <D.18701>;
  <D.18700>:
  if (__len == 0) goto <D.18702>; else goto <D.18703>;
  <D.18702>:
  D.18704 = __builtin_constant_p (__ch);
  if (D.18704 == 0) goto <D.18697>; else goto <D.18705>;
  <D.18705>:
  if (__ch != 0) goto <D.18697>; else goto <D.18698>;
  <D.18697>:
  __warn_memset_zero_len ();
  D.18706 = __dest;
  return D.18706;
  <D.18698>:
  <D.18703>:
  <D.18701>:
  D.18707 = __builtin_object_size (__dest, 0);
  D.18706 = __builtin___memset_chk (__dest, __ch, __len, D.18707);
  return D.18706;
}


dfs1 (struct HashEntry * obj_entry, struct HashEntry * src)
{
  int D.18709;
  _Bool D.18710;
  long int D.18711;
  long int D.18712;
  int dsf1_passes.2;
  int dsf1_passes.3;
  int D.18722;
  long unsigned int D.18725;
  long unsigned int D.18726;
  long unsigned int D.18727;
  long unsigned int D.18728;
  long unsigned int D.18731;
  long unsigned int D.18732;
  long unsigned int D.18733;
  long unsigned int D.18734;
  long unsigned int D.18735;
  long unsigned int D.18736;
  void * dst.4;
  struct MonoObject * dst.5;
  int D.18741;
  struct HashEntry * D.18744;
  struct MonoObject * dst.6;
  int D.18748;
  struct HashEntry * D.18751;
  long unsigned int D.18752;
  long unsigned int D.18753;
  int D.18754;
  void * dst.7;
  struct MonoObject * dst.8;
  int D.18759;
  struct HashEntry * D.18762;
  long unsigned int D.18763;
  long unsigned int D.18764;
  int D.18765;
  struct MonoObject * dst.9;
  int D.18769;
  struct HashEntry * D.18772;
  long unsigned int D.18773;
  long unsigned int D.18776;
  int D.18777;
  int D.18778;
  unsigned int D.18781;
  unsigned int el_size.10;
  unsigned int D.18783;
  sizetype D.18784;
  void * dst.11;
  struct MonoObject * dst.12;
  int D.18789;
  struct HashEntry * D.18792;
  int D.18796;
  int D.18797;
  long unsigned int D.18798;
  long unsigned int D.18799;
  long unsigned int D.18800;
  long unsigned int D.18801;
  void * * D.18802;
  void * dst.13;
  struct MonoObject * dst.14;
  int D.18807;
  struct HashEntry * D.18810;
  sizetype D.18811;
  long unsigned int D.18815;
  void * dst.15;
  struct MonoObject * dst.16;
  int D.18822;
  struct HashEntry * D.18825;
  long unsigned int D.18826;
  void * dst.17;
  struct MonoObject * dst.18;
  int D.18833;
  struct HashEntry * D.18836;
  long unsigned int D.18837;
  unsigned int D.18838;
  unsigned int D.18839;
  struct MonoVTable * D.18842;
  struct MonoClass * D.18843;
  const char * D.18844;
  const char * D.18845;
  gsize * bitmap_data.19;
  long unsigned int D.18847;
  void * dst.20;
  struct MonoObject * dst.21;
  int D.18854;
  struct HashEntry * D.18857;
  int bwords.22;
  long unsigned int D.18859;
  gsize * mbitmap_data.23;
  long unsigned int D.18861;
  unsigned int D.18862;
  unsigned int D.18863;
  struct MonoClass * D.18864;
  unsigned int el_size.24;
  unsigned int D.18866;
  sizetype D.18867;
  const char * D.18870;
  const char * D.18871;
  gsize * bitmap_data.25;
  long unsigned int D.18873;
  void * dst.26;
  struct MonoObject * dst.27;
  int D.18880;
  struct HashEntry * D.18883;
  unsigned int bwords.28;
  sizetype D.18885;
  int current_time.29;
  int current_time.30;
  int current_time.31;

  D.18709 = dfs_stack.size;
  D.18710 = D.18709 != 0;
  D.18711 = (long int) D.18710;
  D.18712 = __builtin_expect (D.18711, 0);
  if (D.18712 != 0) goto <D.18713>; else goto <D.18714>;
  <D.18713>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 423, "dfs_stack.size == 0");
  <D.18714>:
  dyn_array_ptr_add (&dfs_stack, src);
  dyn_array_ptr_add (&dfs_stack, obj_entry);
  <D.18363>:
  {
    struct MonoObject * obj;
    char * start;

    dsf1_passes.2 = dsf1_passes;
    dsf1_passes.3 = dsf1_passes.2 + 1;
    dsf1_passes = dsf1_passes.3;
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    if (obj_entry != 0B) goto <D.18717>; else goto <D.18718>;
    <D.18717>:
    src = dyn_array_ptr_pop (&dfs_stack);
    obj = obj_entry->obj;
    start = obj;
    if (src != 0B) goto <D.18719>; else goto <D.18720>;
    <D.18719>:
    add_source (obj_entry, src);
    goto <D.18721>;
    <D.18720>:
    <D.18721>:
    D.18722 = obj_entry->is_visited;
    if (D.18722 != 0) goto <D.18723>; else goto <D.18724>;
    <D.18723>:
    // predicted unlikely by continue predictor.
    goto <D.18264>;
    <D.18724>:
    obj_entry->is_visited = 1;
    dyn_array_ptr_add (&dfs_stack, obj_entry);
    dyn_array_ptr_add (&dfs_stack, 0B);
    {
      struct GCVTable * vt;
      mword desc;

      D.18725 = MEM[(mword *)start];
      D.18726 = D.18725 & 18446744073709551612;
      vt = (struct GCVTable *) D.18726;
      desc = vt->desc;
      D.18727 = desc & 7;
      switch (D.18727) <default: <D.18362>, case 1: <D.18267>, case 2: <D.18276>, case 3: <D.18326>, case 4: <D.18286>, case 5: <D.18319>, case 6: <D.18340>, case 7: <D.18361>>
      <D.18267>:
      D.18728 = desc & 4294901760;
      if (D.18728 != 0) goto <D.18729>; else goto <D.18730>;
      <D.18729>:
      {
        void * * _objptr_end;
        void * * _objptr;

        _objptr = start;
        D.18731 = desc >> 16;
        D.18732 = D.18731 & 255;
        D.18733 = D.18732 * 8;
        _objptr = _objptr + D.18733;
        D.18734 = desc >> 24;
        D.18735 = D.18734 & 255;
        D.18736 = D.18735 * 8;
        _objptr_end = _objptr + D.18736;
        {
          struct MonoObject * dst;

          try
            {
              dst.4 = *_objptr;
              dst = dst.4;
              dst.5 = dst;
              if (dst.5 != 0B) goto <D.18739>; else goto <D.18740>;
              <D.18739>:
              D.18741 = object_is_live (&dst);
              if (D.18741 == 0) goto <D.18742>; else goto <D.18743>;
              <D.18742>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.5 = dst;
              D.18744 = get_hash_entry (dst.5, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18744);
              <D.18743>:
              <D.18740>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 8;
        goto <D.18273>;
        <D.18272>:
        {
          struct MonoObject * dst;

          try
            {
              dst.4 = *_objptr;
              dst = dst.4;
              dst.6 = dst;
              if (dst.6 != 0B) goto <D.18746>; else goto <D.18747>;
              <D.18746>:
              D.18748 = object_is_live (&dst);
              if (D.18748 == 0) goto <D.18749>; else goto <D.18750>;
              <D.18749>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.6 = dst;
              D.18751 = get_hash_entry (dst.6, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18751);
              <D.18750>:
              <D.18747>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 8;
        <D.18273>:
        if (_objptr < _objptr_end) goto <D.18272>; else goto <D.18274>;
        <D.18274>:
      }
      <D.18730>:
      goto <D.18275>;
      <D.18276>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 16;
        _objptr = _objptr + 16;
        {
          int _index;

          _index = __builtin_ctzl (_bmap);
          D.18752 = (long unsigned int) _index;
          D.18753 = D.18752 * 8;
          _objptr = _objptr + D.18753;
          D.18754 = _index + 1;
          _bmap = _bmap >> D.18754;
          {
            struct MonoObject * dst;

            try
              {
                dst.7 = *_objptr;
                dst = dst.7;
                dst.8 = dst;
                if (dst.8 != 0B) goto <D.18757>; else goto <D.18758>;
                <D.18757>:
                D.18759 = object_is_live (&dst);
                if (D.18759 == 0) goto <D.18760>; else goto <D.18761>;
                <D.18760>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.8 = dst;
                D.18762 = get_hash_entry (dst.8, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18762);
                <D.18761>:
                <D.18758>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 8;
        }
        goto <D.18284>;
        <D.18283>:
        {
          int _index;

          _index = __builtin_ctzl (_bmap);
          D.18763 = (long unsigned int) _index;
          D.18764 = D.18763 * 8;
          _objptr = _objptr + D.18764;
          D.18765 = _index + 1;
          _bmap = _bmap >> D.18765;
          {
            struct MonoObject * dst;

            try
              {
                dst.7 = *_objptr;
                dst = dst.7;
                dst.9 = dst;
                if (dst.9 != 0B) goto <D.18767>; else goto <D.18768>;
                <D.18767>:
                D.18769 = object_is_live (&dst);
                if (D.18769 == 0) goto <D.18770>; else goto <D.18771>;
                <D.18770>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.9 = dst;
                D.18772 = get_hash_entry (dst.9, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18772);
                <D.18771>:
                <D.18768>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 8;
        }
        <D.18284>:
        if (_bmap != 0) goto <D.18283>; else goto <D.18285>;
        <D.18285>:
      }
      goto <D.18275>;
      <D.18286>:
      D.18773 = desc & 4294950912;
      if (D.18773 != 0) goto <D.18774>; else goto <D.18775>;
      <D.18774>:
      {
        int el_size;
        int etype;

        D.18776 = desc >> 3;
        D.18777 = (int) D.18776;
        el_size = D.18777 & 1023;
        D.18778 = (int) desc;
        etype = D.18778 & 49152;
        if (etype == 16384) goto <D.18779>; else goto <D.18780>;
        <D.18779>:
        {
          void * * p;
          void * * end_refs;

          p = start + 32;
          D.18781 = MEM[(struct MonoArray *)start].max_length;
          el_size.10 = (unsigned int) el_size;
          D.18783 = D.18781 * el_size.10;
          D.18784 = (sizetype) D.18783;
          end_refs = p + D.18784;
          goto <D.18293>;
          <D.18292>:
          {
            struct MonoObject * dst;

            try
              {
                dst.11 = *p;
                dst = dst.11;
                dst.12 = dst;
                if (dst.12 != 0B) goto <D.18787>; else goto <D.18788>;
                <D.18787>:
                D.18789 = object_is_live (&dst);
                if (D.18789 == 0) goto <D.18790>; else goto <D.18791>;
                <D.18790>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.12 = dst;
                D.18792 = get_hash_entry (dst.12, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18792);
                <D.18791>:
                <D.18788>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          p = p + 8;
          <D.18293>:
          if (p < end_refs) goto <D.18292>; else goto <D.18294>;
          <D.18294>:
        }
        goto <D.18793>;
        <D.18780>:
        if (etype == 32768) goto <D.18794>; else goto <D.18795>;
        <D.18794>:
        {
          int offset;
          int num_refs;
          char * e_start;
          char * e_end;

          D.18731 = desc >> 16;
          D.18796 = (int) D.18731;
          offset = D.18796 & 255;
          D.18734 = desc >> 24;
          D.18797 = (int) D.18734;
          num_refs = D.18797 & 255;
          e_start = start + 32;
          D.18781 = MEM[(struct MonoArray *)start].max_length;
          el_size.10 = (unsigned int) el_size;
          D.18783 = D.18781 * el_size.10;
          D.18784 = (sizetype) D.18783;
          e_end = e_start + D.18784;
          goto <D.18306>;
          <D.18305>:
          {
            void * * p;
            int i;

            p = e_start;
            D.18798 = (long unsigned int) offset;
            D.18799 = D.18798 * 8;
            p = p + D.18799;
            i = 0;
            goto <D.18303>;
            <D.18302>:
            {
              struct MonoObject * dst;

              try
                {
                  D.18800 = (long unsigned int) i;
                  D.18801 = D.18800 * 8;
                  D.18802 = p + D.18801;
                  dst.13 = *D.18802;
                  dst = dst.13;
                  dst.14 = dst;
                  if (dst.14 != 0B) goto <D.18805>; else goto <D.18806>;
                  <D.18805>:
                  D.18807 = object_is_live (&dst);
                  if (D.18807 == 0) goto <D.18808>; else goto <D.18809>;
                  <D.18808>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.14 = dst;
                  D.18810 = get_hash_entry (dst.14, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18810);
                  <D.18809>:
                  <D.18806>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            i = i + 1;
            <D.18303>:
            if (i < num_refs) goto <D.18302>; else goto <D.18304>;
            <D.18304>:
            D.18811 = (sizetype) el_size;
            e_start = e_start + D.18811;
          }
          <D.18306>:
          if (e_start < e_end) goto <D.18305>; else goto <D.18307>;
          <D.18307>:
        }
        goto <D.18812>;
        <D.18795>:
        if (etype == 49152) goto <D.18813>; else goto <D.18814>;
        <D.18813>:
        {
          char * e_start;
          char * e_end;

          e_start = start + 32;
          D.18781 = MEM[(struct MonoArray *)start].max_length;
          el_size.10 = (unsigned int) el_size;
          D.18783 = D.18781 * el_size.10;
          D.18784 = (sizetype) D.18783;
          e_end = e_start + D.18784;
          goto <D.18317>;
          <D.18316>:
          {
            void * * p;
            gsize _bmap;

            p = e_start;
            _bmap = desc >> 16;
            goto <D.18314>;
            <D.18313>:
            D.18815 = _bmap & 1;
            if (D.18815 != 0) goto <D.18816>; else goto <D.18817>;
            <D.18816>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.15 = *p;
                  dst = dst.15;
                  dst.16 = dst;
                  if (dst.16 != 0B) goto <D.18820>; else goto <D.18821>;
                  <D.18820>:
                  D.18822 = object_is_live (&dst);
                  if (D.18822 == 0) goto <D.18823>; else goto <D.18824>;
                  <D.18823>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.16 = dst;
                  D.18825 = get_hash_entry (dst.16, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18825);
                  <D.18824>:
                  <D.18821>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.18817>:
            _bmap = _bmap >> 1;
            p = p + 8;
            <D.18314>:
            if (_bmap != 0) goto <D.18313>; else goto <D.18315>;
            <D.18315>:
            D.18811 = (sizetype) el_size;
            e_start = e_start + D.18811;
          }
          <D.18317>:
          if (e_start < e_end) goto <D.18316>; else goto <D.18318>;
          <D.18318>:
        }
        <D.18814>:
        <D.18812>:
        <D.18793>:
      }
      <D.18775>:
      goto <D.18275>;
      <D.18319>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 3;
        _objptr = _objptr + 16;
        goto <D.18324>;
        <D.18323>:
        D.18826 = _bmap & 1;
        if (D.18826 != 0) goto <D.18827>; else goto <D.18828>;
        <D.18827>:
        {
          struct MonoObject * dst;

          try
            {
              dst.17 = *_objptr;
              dst = dst.17;
              dst.18 = dst;
              if (dst.18 != 0B) goto <D.18831>; else goto <D.18832>;
              <D.18831>:
              D.18833 = object_is_live (&dst);
              if (D.18833 == 0) goto <D.18834>; else goto <D.18835>;
              <D.18834>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.18 = dst;
              D.18836 = get_hash_entry (dst.18, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18836);
              <D.18835>:
              <D.18832>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        <D.18828>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.18324>:
        if (_bmap != 0) goto <D.18323>; else goto <D.18325>;
        <D.18325>:
      }
      goto <D.18275>;
      <D.18326>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        int bwords;
        void * * start_run;

        _objptr = start;
        bitmap_data = sgen_get_complex_descriptor (desc);
        D.18837 = *bitmap_data;
        D.18838 = (unsigned int) D.18837;
        D.18839 = D.18838 + 4294967295;
        bwords = (int) D.18839;
        start_run = _objptr;
        bitmap_data = bitmap_data + 8;
        if (0 != 0) goto <D.18840>; else goto <D.18841>;
        <D.18840>:
        {
          struct MonoObject * myobj;

          myobj = start;
          D.18842 = myobj->vtable;
          D.18843 = D.18842->klass;
          D.18844 = D.18843->name_space;
          D.18842 = myobj->vtable;
          D.18843 = D.18842->klass;
          D.18845 = D.18843->name;
          monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18844, D.18845);
        }
        <D.18841>:
        goto <D.18338>;
        <D.18337>:
        {
          gsize _bmap;

          bitmap_data.19 = bitmap_data;
          bitmap_data = bitmap_data.19 + 8;
          _bmap = *bitmap_data.19;
          _objptr = start_run;
          goto <D.18335>;
          <D.18334>:
          D.18847 = _bmap & 1;
          if (D.18847 != 0) goto <D.18848>; else goto <D.18849>;
          <D.18848>:
          {
            struct MonoObject * dst;

            try
              {
                dst.20 = *_objptr;
                dst = dst.20;
                dst.21 = dst;
                if (dst.21 != 0B) goto <D.18852>; else goto <D.18853>;
                <D.18852>:
                D.18854 = object_is_live (&dst);
                if (D.18854 == 0) goto <D.18855>; else goto <D.18856>;
                <D.18855>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.21 = dst;
                D.18857 = get_hash_entry (dst.21, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18857);
                <D.18856>:
                <D.18853>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          <D.18849>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.18335>:
          if (_bmap != 0) goto <D.18334>; else goto <D.18336>;
          <D.18336>:
          start_run = start_run + 512;
        }
        <D.18338>:
        bwords.22 = bwords;
        bwords = bwords.22 + -1;
        if (bwords.22 > 0) goto <D.18337>; else goto <D.18339>;
        <D.18339>:
      }
      goto <D.18275>;
      <D.18340>:
      {
        gsize * mbitmap_data;
        int mbwords;
        int el_size;
        char * e_start;
        char * e_end;

        D.18859 = vt->desc;
        mbitmap_data = sgen_get_complex_descriptor (D.18859);
        mbitmap_data.23 = mbitmap_data;
        mbitmap_data = mbitmap_data.23 + 8;
        D.18861 = *mbitmap_data.23;
        D.18862 = (unsigned int) D.18861;
        D.18863 = D.18862 + 4294967295;
        mbwords = (int) D.18863;
        D.18864 = vt->klass;
        el_size = mono_array_element_size (D.18864);
        e_start = start + 32;
        D.18781 = MEM[(struct MonoArray *)start].max_length;
        el_size.24 = (unsigned int) el_size;
        D.18866 = D.18781 * el_size.24;
        D.18867 = (sizetype) D.18866;
        e_end = e_start + D.18867;
        if (0 != 0) goto <D.18868>; else goto <D.18869>;
        <D.18868>:
        D.18859 = vt->desc;
        D.18864 = vt->klass;
        D.18870 = D.18864->name_space;
        D.18864 = vt->klass;
        D.18871 = D.18864->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18859, D.18870, D.18871);
        <D.18869>:
        goto <D.18359>;
        <D.18358>:
        {
          void * * _objptr;
          gsize * bitmap_data;
          unsigned int bwords;

          _objptr = e_start;
          bitmap_data = mbitmap_data;
          bwords = (unsigned int) mbwords;
          goto <D.18356>;
          <D.18355>:
          {
            gsize _bmap;
            void * * start_run;

            bitmap_data.25 = bitmap_data;
            bitmap_data = bitmap_data.25 + 8;
            _bmap = *bitmap_data.25;
            start_run = _objptr;
            goto <D.18353>;
            <D.18352>:
            D.18873 = _bmap & 1;
            if (D.18873 != 0) goto <D.18874>; else goto <D.18875>;
            <D.18874>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.26 = *_objptr;
                  dst = dst.26;
                  dst.27 = dst;
                  if (dst.27 != 0B) goto <D.18878>; else goto <D.18879>;
                  <D.18878>:
                  D.18880 = object_is_live (&dst);
                  if (D.18880 == 0) goto <D.18881>; else goto <D.18882>;
                  <D.18881>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.27 = dst;
                  D.18883 = get_hash_entry (dst.27, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18883);
                  <D.18882>:
                  <D.18879>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.18875>:
            _bmap = _bmap >> 1;
            _objptr = _objptr + 8;
            <D.18353>:
            if (_bmap != 0) goto <D.18352>; else goto <D.18354>;
            <D.18354>:
            _objptr = start_run + 512;
          }
          <D.18356>:
          bwords.28 = bwords;
          bwords = bwords.28 + 4294967295;
          if (bwords.28 != 0) goto <D.18355>; else goto <D.18357>;
          <D.18357>:
          D.18885 = (sizetype) el_size;
          e_start = e_start + D.18885;
        }
        <D.18359>:
        if (e_start < e_end) goto <D.18358>; else goto <D.18360>;
        <D.18360>:
      }
      goto <D.18275>;
      <D.18361>:
      goto <D.18275>;
      <D.18362>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
      <D.18275>:
    }
    goto <D.18886>;
    <D.18718>:
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    current_time.29 = current_time;
    current_time.30 = current_time.29;
    current_time.31 = current_time.30 + 1;
    current_time = current_time.31;
    register_finishing_time (obj_entry, current_time.30);
    <D.18886>:
  }
  <D.18264>:
  D.18709 = dfs_stack.size;
  if (D.18709 > 0) goto <D.18363>; else goto <D.18364>;
  <D.18364>:
}


add_source (struct HashEntry * entry, struct HashEntry * src)
{
  struct DynArray * D.18892;

  D.18892 = &entry->srcs;
  dyn_array_ptr_add (D.18892, src);
}


object_is_live (struct MonoObject * * objp)
{
  struct MonoObject * iftmp.32;
  long unsigned int D.18894;
  long unsigned int D.18895;
  long unsigned int D.18898;
  gboolean D.18902;
  void * D.18903;
  _Bool D.18904;
  int D.18905;
  void * D.18908;
  _Bool D.18909;
  struct MonoObject * obj;
  struct MonoObject * fwd;

  obj = *objp;
  D.18894 = MEM[(mword *)obj];
  D.18895 = D.18894 & 1;
  if (D.18895 != 0) goto <D.18896>; else goto <D.18897>;
  <D.18896>:
  D.18894 = MEM[(mword *)obj];
  D.18898 = D.18894 & 18446744073709551612;
  iftmp.32 = (struct MonoObject *) D.18898;
  goto <D.18899>;
  <D.18897>:
  iftmp.32 = 0B;
  <D.18899>:
  fwd = iftmp.32;
  if (fwd != 0B) goto <D.18900>; else goto <D.18901>;
  <D.18900>:
  *objp = fwd;
  D.18903 = sgen_hash_table_lookup (&hash_table, fwd);
  D.18904 = D.18903 == 0B;
  D.18902 = (gboolean) D.18904;
  return D.18902;
  <D.18901>:
  D.18905 = sgen_object_is_live (obj);
  if (D.18905 == 0) goto <D.18906>; else goto <D.18907>;
  <D.18906>:
  D.18902 = 0;
  return D.18902;
  <D.18907>:
  D.18908 = sgen_hash_table_lookup (&hash_table, obj);
  D.18909 = D.18908 == 0B;
  D.18902 = (gboolean) D.18909;
  return D.18902;
}


dyn_array_ptr_pop (struct DynArray * da)
{
  int D.18911;
  _Bool D.18912;
  long int D.18913;
  long int D.18914;
  char * D.18917;
  long unsigned int D.18918;
  long unsigned int D.18919;
  sizetype D.18920;
  void * * D.18921;
  int D.18922;
  void * D.18923;
  void * p;

  D.18911 = da->size;
  D.18912 = D.18911 <= 0;
  D.18913 = (long int) D.18912;
  D.18914 = __builtin_expect (D.18913, 0);
  if (D.18914 != 0) goto <D.18915>; else goto <D.18916>;
  <D.18915>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 142, "da->size > 0");
  <D.18916>:
  D.18917 = da->data;
  D.18911 = da->size;
  D.18918 = (long unsigned int) D.18911;
  D.18919 = D.18918 * 8;
  D.18920 = D.18919 + 18446744073709551608;
  D.18921 = D.18917 + D.18920;
  p = *D.18921;
  D.18911 = da->size;
  D.18922 = D.18911 + -1;
  da->size = D.18922;
  D.18923 = p;
  return D.18923;
}


register_finishing_time (struct HashEntry * entry, int t)
{
  int D.18925;
  _Bool D.18926;
  long int D.18927;
  long int D.18928;

  D.18925 = entry->finishing_time;
  D.18926 = D.18925 >= 0;
  D.18927 = (long int) D.18926;
  D.18928 = __builtin_expect (D.18927, 0);
  if (D.18928 != 0) goto <D.18929>; else goto <D.18930>;
  <D.18929>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 387, "entry->finishing_time < 0");
  <D.18930>:
  entry->finishing_time = t;
}


sgen_bridge_processing_finish (int generation)
{
  int D.18932;
  int bridge_processing_in_progress.33;
  _Bool D.18936;
  long int D.18937;
  long int D.18938;
  unsigned int D.18941;
  long unsigned int D.18942;
  long unsigned int D.18943;
  long unsigned int D.18944;
  long unsigned int D.18945;
  int D.18946;
  _Bool D.18947;
  long int D.18948;
  long int D.18949;
  int j.34;
  long unsigned int D.18953;
  long unsigned int D.18954;
  struct HashEntry * * D.18955;
  int D.18956;
  int fist_pass_links.35;
  int fist_pass_links.36;
  struct SgenHashTableEntry * D.18959;
  unsigned int D.18960;
  unsigned int j.37;
  _Bool D.18962;
  long int D.18963;
  long int D.18964;
  long unsigned int D.18967;
  long int D.18968;
  long int D.18969;
  int D.18970;
  long unsigned int step_3.38;
  long unsigned int D.18972;
  long unsigned int D.18973;
  struct HashEntry * * D.18974;
  int D.18975;
  void * current_scc.39;
  struct SCC * current_scc.40;
  struct DynArray * D.18980;
  unsigned int i.41;
  int D.18982;
  int second_pass_links.42;
  int second_pass_links.43;
  long int D.18985;
  long int D.18986;
  int D.18987;
  long unsigned int step_4.44;
  char * D.18989;
  int D.18990;
  int D.18991;
  sizetype D.18992;
  int D.18993;
  _Bool D.18994;
  long int D.18995;
  long int D.18996;
  int D.18999;
  int D.19002;
  int sccs_links.45;
  int sccs_links.46;
  int max_sccs_links.47;
  int max_sccs_links.48;
  int D.19007;
  long unsigned int D.19008;
  long unsigned int D.19009;
  int D.19010;
  long unsigned int D.19013;
  long unsigned int D.19014;
  struct MonoGCBridgeSCC * * D.19015;
  long unsigned int D.19016;
  long unsigned int D.19017;
  long unsigned int D.19018;
  void * D.19019;
  struct MonoGCBridgeSCC * D.19020;
  int j.49;
  int D.19022;
  long unsigned int D.19023;
  long unsigned int D.19024;
  int D.19025;
  int D.19028;
  int D.19029;
  sizetype D.19030;
  int D.19031;
  long unsigned int D.19032;
  long unsigned int D.19033;
  struct MonoGCBridgeSCC * * D.19034;
  struct MonoGCBridgeSCC * D.19035;
  int D.19036;
  int D.19037;
  int D.19038;
  struct MonoObject * D.19039;
  struct SgenHashTableEntry * D.19040;
  long unsigned int D.19041;
  long unsigned int D.19042;
  int D.19043;
  char * D.19046;
  long unsigned int D.19047;
  long unsigned int D.19048;
  int * D.19049;
  int D.19050;
  int D.19051;
  sizetype D.19052;
  int D.19053;
  struct MonoGCBridgeXRef * D.19056;
  int D.19057;
  int D.19058;
  int D.19059;
  int D.19060;
  int D.19065;
  struct DynArray * D.19068;
  void (*<T2f74>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.19069;
  struct MonoGCBridgeSCC * * D.19070;
  struct MonoGCBridgeSCC * D.19071;
  int D.19072;
  _Bool D.19073;
  unsigned char alive.50;
  struct MonoObject * D.19075;
  int D.19078;
  long unsigned int D.19081;
  long unsigned int D.19082;
  long unsigned int D.19083;
  long unsigned int step_1.51;
  float D.19085;
  float D.19086;
  double D.19087;
  long unsigned int step_2.52;
  float D.19089;
  float D.19090;
  double D.19091;
  long unsigned int step_3.53;
  float D.19093;
  float D.19094;
  double D.19095;
  long unsigned int step_4.54;
  float D.19097;
  float D.19098;
  double D.19099;
  long unsigned int step_5.55;
  float D.19101;
  float D.19102;
  double D.19103;
  long unsigned int step_6.56;
  float D.19105;
  float D.19106;
  double D.19107;
  long unsigned int step_7.57;
  float D.19109;
  float D.19110;
  double D.19111;
  long unsigned int step_8.58;
  float D.19113;
  float D.19114;
  double D.19115;
  int dsf1_passes.59;
  int dsf2_passes.60;
  int i;
  int j;
  int num_sccs;
  int num_xrefs;
  int max_entries;
  int max_xrefs;
  int hash_table_size;
  int sccs_size;
  struct MonoObject * obj;
  struct HashEntry * entry;
  int num_registered_bridges;
  struct HashEntry * * all_entries;
  struct MonoGCBridgeSCC * * api_sccs;
  struct MonoGCBridgeXRef * api_xrefs;
  struct SgenHashTable alive_hash;
  gint64 atv;
  gint64 btv;

  try
    {
      alive_hash = *.LC0;
      D.18932 = registered_bridges.size;
      if (D.18932 == 0) goto <D.18933>; else goto <D.18934>;
      <D.18933>:
      return;
      <D.18934>:
      bridge_processing_in_progress.33 = bridge_processing_in_progress;
      D.18936 = bridge_processing_in_progress.33 == 0;
      D.18937 = (long int) D.18936;
      D.18938 = __builtin_expect (D.18937, 0);
      if (D.18938 != 0) goto <D.18939>; else goto <D.18940>;
      <D.18939>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 620, "bridge_processing_in_progress");
      <D.18940>:
      atv = mono_100ns_ticks ();
      D.18941 = hash_table.num_entries;
      D.18942 = (long unsigned int) D.18941;
      D.18943 = D.18942 * 8;
      all_entries = sgen_alloc_internal_dynamic (D.18943, 21, 1);
      j = 0;
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

        __hash_table = &hash_table;
        __table = __hash_table->table;
        __i = 0;
        goto <D.18461>;
        <D.18460>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.18944 = (long unsigned int) __i;
          D.18945 = D.18944 * 8;
          __iter = __table + D.18945;
          goto <D.18458>;
          <D.18457>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.18946 = entry->finishing_time;
            D.18947 = D.18946 < 0;
            D.18948 = (long int) D.18947;
            D.18949 = __builtin_expect (D.18948, 0);
            if (D.18949 != 0) goto <D.18950>; else goto <D.18951>;
            <D.18950>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 630, "entry->finishing_time >= 0");
            <D.18951>:
            j.34 = j;
            j = j.34 + 1;
            D.18953 = (long unsigned int) j.34;
            D.18954 = D.18953 * 8;
            D.18955 = all_entries + D.18954;
            *D.18955 = entry;
            D.18956 = entry->srcs.size;
            fist_pass_links.35 = fist_pass_links;
            fist_pass_links.36 = D.18956 + fist_pass_links.35;
            fist_pass_links = fist_pass_links.36;
          }
          __iter = __next;
          <D.18458>:
          D.18959 = *__iter;
          if (D.18959 != 0B) goto <D.18457>; else goto <D.18459>;
          <D.18459>:
        }
        __i = __i + 1;
        <D.18461>:
        D.18960 = hash_table.size;
        if (D.18960 > __i) goto <D.18460>; else goto <D.18462>;
        <D.18462>:
      }
      j.37 = (unsigned int) j;
      D.18941 = hash_table.num_entries;
      D.18962 = j.37 != D.18941;
      D.18963 = (long int) D.18962;
      D.18964 = __builtin_expect (D.18963, 0);
      if (D.18964 != 0) goto <D.18965>; else goto <D.18966>;
      <D.18965>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 634, "j == hash_table.num_entries");
      <D.18966>:
      D.18941 = hash_table.num_entries;
      hash_table_size = (int) D.18941;
      D.18941 = hash_table.num_entries;
      D.18967 = (long unsigned int) D.18941;
      sgen_qsort (all_entries, D.18967, 8, compare_hash_entries);
      btv = mono_100ns_ticks ();
      D.18968 = btv - atv;
      D.18969 = D.18968 / 10;
      D.18970 = (int) D.18969;
      step_3.38 = (long unsigned int) D.18970;
      step_3 = step_3.38;
      dyn_array_init (&sccs, 40);
      i = 0;
      goto <D.18466>;
      <D.18465>:
      {
        struct HashEntry * entry;

        D.18972 = (long unsigned int) i;
        D.18973 = D.18972 * 8;
        D.18974 = all_entries + D.18973;
        entry = *D.18974;
        D.18975 = entry->scc_index;
        if (D.18975 < 0) goto <D.18976>; else goto <D.18977>;
        <D.18976>:
        {
          int index;

          index = sccs.size;
          current_scc.39 = dyn_array_add (&sccs);
          current_scc = current_scc.39;
          current_scc.40 = current_scc;
          current_scc.40->index = index;
          current_scc.40 = current_scc;
          current_scc.40->num_bridge_entries = 0;
          current_scc.40 = current_scc;
          current_scc.40->api_index = -1;
          current_scc.40 = current_scc;
          D.18980 = &current_scc.40->xrefs;
          dyn_array_int_init (D.18980);
          dfs2 (entry);
        }
        <D.18977>:
      }
      i = i + 1;
      <D.18466>:
      i.41 = (unsigned int) i;
      D.18941 = hash_table.num_entries;
      if (i.41 < D.18941) goto <D.18465>; else goto <D.18467>;
      <D.18467>:
      sccs_size = sccs.size;
      i = 0;
      goto <D.18470>;
      <D.18469>:
      {
        struct HashEntry * entry;

        D.18972 = (long unsigned int) i;
        D.18973 = D.18972 * 8;
        D.18974 = all_entries + D.18973;
        entry = *D.18974;
        D.18982 = entry->srcs.size;
        second_pass_links.42 = second_pass_links;
        second_pass_links.43 = D.18982 + second_pass_links.42;
        second_pass_links = second_pass_links.43;
      }
      i = i + 1;
      <D.18470>:
      i.41 = (unsigned int) i;
      D.18941 = hash_table.num_entries;
      if (i.41 < D.18941) goto <D.18469>; else goto <D.18471>;
      <D.18471>:
      atv = mono_100ns_ticks ();
      D.18985 = atv - btv;
      D.18986 = D.18985 / 10;
      D.18987 = (int) D.18986;
      step_4.44 = (long unsigned int) D.18987;
      step_4 = step_4.44;
      dyn_array_uninit (&dfs_stack);
      num_sccs = 0;
      i = 0;
      goto <D.18474>;
      <D.18473>:
      {
        struct SCC * scc;

        D.18989 = sccs.data;
        D.18990 = sccs.elem_size;
        D.18991 = D.18990 * i;
        D.18992 = (sizetype) D.18991;
        scc = D.18989 + D.18992;
        D.18993 = scc->index;
        D.18994 = D.18993 != i;
        D.18995 = (long int) D.18994;
        D.18996 = __builtin_expect (D.18995, 0);
        if (D.18996 != 0) goto <D.18997>; else goto <D.18998>;
        <D.18997>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 680, "scc->index == i");
        <D.18998>:
        D.18999 = scc->num_bridge_entries;
        if (D.18999 != 0) goto <D.19000>; else goto <D.19001>;
        <D.19000>:
        num_sccs = num_sccs + 1;
        <D.19001>:
        D.19002 = scc->xrefs.size;
        sccs_links.45 = sccs_links;
        sccs_links.46 = D.19002 + sccs_links.45;
        sccs_links = sccs_links.46;
        D.19002 = scc->xrefs.size;
        max_sccs_links.47 = max_sccs_links;
        max_sccs_links.48 = MAX_EXPR <D.19002, max_sccs_links.47>;
        max_sccs_links = max_sccs_links.48;
      }
      i = i + 1;
      <D.18474>:
      D.19007 = sccs.size;
      if (D.19007 > i) goto <D.18473>; else goto <D.18475>;
      <D.18475>:
      D.19008 = (long unsigned int) num_sccs;
      D.19009 = D.19008 * 8;
      api_sccs = sgen_alloc_internal_dynamic (D.19009, 21, 1);
      num_xrefs = 0;
      j = 0;
      i = 0;
      goto <D.18479>;
      <D.18478>:
      {
        struct SCC * scc;

        D.18989 = sccs.data;
        D.18990 = sccs.elem_size;
        D.18991 = D.18990 * i;
        D.18992 = (sizetype) D.18991;
        scc = D.18989 + D.18992;
        D.19010 = scc->num_bridge_entries;
        if (D.19010 == 0) goto <D.19011>; else goto <D.19012>;
        <D.19011>:
        // predicted unlikely by continue predictor.
        goto <D.18477>;
        <D.19012>:
        D.19013 = (long unsigned int) j;
        D.19014 = D.19013 * 8;
        D.19015 = api_sccs + D.19014;
        D.19010 = scc->num_bridge_entries;
        D.19016 = (long unsigned int) D.19010;
        D.19017 = D.19016 + 1;
        D.19018 = D.19017 * 8;
        D.19019 = sgen_alloc_internal_dynamic (D.19018, 21, 1);
        *D.19015 = D.19019;
        D.19013 = (long unsigned int) j;
        D.19014 = D.19013 * 8;
        D.19015 = api_sccs + D.19014;
        D.19020 = *D.19015;
        D.19020->is_alive = 0;
        D.19013 = (long unsigned int) j;
        D.19014 = D.19013 * 8;
        D.19015 = api_sccs + D.19014;
        D.19020 = *D.19015;
        D.19010 = scc->num_bridge_entries;
        D.19020->num_objs = D.19010;
        scc->num_bridge_entries = 0;
        j.49 = j;
        j = j.49 + 1;
        scc->api_index = j.49;
        D.19022 = scc->xrefs.size;
        num_xrefs = D.19022 + num_xrefs;
      }
      <D.18477>:
      i = i + 1;
      <D.18479>:
      D.19007 = sccs.size;
      if (D.19007 > i) goto <D.18478>; else goto <D.18480>;
      <D.18480>:
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

        __hash_table = &hash_table;
        __table = __hash_table->table;
        __i = 0;
        goto <D.18492>;
        <D.18491>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.19023 = (long unsigned int) __i;
          D.19024 = D.19023 * 8;
          __iter = __table + D.19024;
          goto <D.18489>;
          <D.18488>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.19025 = entry->is_bridge;
            if (D.19025 != 0) goto <D.19026>; else goto <D.19027>;
            <D.19026>:
            {
              struct SCC * scc;

              D.18989 = sccs.data;
              D.19028 = entry->scc_index;
              D.18990 = sccs.elem_size;
              D.19029 = D.19028 * D.18990;
              D.19030 = (sizetype) D.19029;
              scc = D.18989 + D.19030;
              D.19031 = scc->api_index;
              D.19032 = (long unsigned int) D.19031;
              D.19033 = D.19032 * 8;
              D.19034 = api_sccs + D.19033;
              D.19035 = *D.19034;
              D.19036 = scc->num_bridge_entries;
              D.19037 = D.19036;
              D.19038 = D.19037 + 1;
              scc->num_bridge_entries = D.19038;
              D.19039 = entry->obj;
              D.19035->objs[D.19037] = D.19039;
            }
            <D.19027>:
          }
          __iter = __next;
          <D.18489>:
          D.19040 = *__iter;
          if (D.19040 != 0B) goto <D.18488>; else goto <D.18490>;
          <D.18490>:
        }
        __i = __i + 1;
        <D.18492>:
        D.18960 = hash_table.size;
        if (D.18960 > __i) goto <D.18491>; else goto <D.18493>;
        <D.18493>:
      }
      D.19041 = (long unsigned int) num_xrefs;
      D.19042 = D.19041 * 8;
      api_xrefs = sgen_alloc_internal_dynamic (D.19042, 21, 1);
      j = 0;
      i = 0;
      goto <D.18503>;
      <D.18502>:
      {
        int k;
        struct SCC * scc;

        D.18989 = sccs.data;
        D.18990 = sccs.elem_size;
        D.18991 = D.18990 * i;
        D.18992 = (sizetype) D.18991;
        scc = D.18989 + D.18992;
        D.19043 = scc->num_bridge_entries;
        if (D.19043 == 0) goto <D.19044>; else goto <D.19045>;
        <D.19044>:
        // predicted unlikely by continue predictor.
        goto <D.18496>;
        <D.19045>:
        k = 0;
        goto <D.18500>;
        <D.18499>:
        {
          struct SCC * src_scc;

          D.18989 = sccs.data;
          D.19046 = scc->xrefs.data;
          D.19047 = (long unsigned int) k;
          D.19048 = D.19047 * 4;
          D.19049 = D.19046 + D.19048;
          D.19050 = *D.19049;
          D.18990 = sccs.elem_size;
          D.19051 = D.19050 * D.18990;
          D.19052 = (sizetype) D.19051;
          src_scc = D.18989 + D.19052;
          D.19053 = src_scc->num_bridge_entries;
          if (D.19053 == 0) goto <D.19054>; else goto <D.19055>;
          <D.19054>:
          // predicted unlikely by continue predictor.
          goto <D.18498>;
          <D.19055>:
          D.19013 = (long unsigned int) j;
          D.19014 = D.19013 * 8;
          D.19056 = api_xrefs + D.19014;
          D.19057 = src_scc->api_index;
          D.19056->src_scc_index = D.19057;
          D.19013 = (long unsigned int) j;
          D.19014 = D.19013 * 8;
          D.19056 = api_xrefs + D.19014;
          D.19058 = scc->api_index;
          D.19056->dst_scc_index = D.19058;
          j = j + 1;
        }
        <D.18498>:
        k = k + 1;
        <D.18500>:
        D.19059 = scc->xrefs.size;
        if (D.19059 > k) goto <D.18499>; else goto <D.18501>;
        <D.18501>:
      }
      <D.18496>:
      i = i + 1;
      <D.18503>:
      D.19007 = sccs.size;
      if (D.19007 > i) goto <D.18502>; else goto <D.18504>;
      <D.18504>:
      btv = mono_100ns_ticks ();
      D.18968 = btv - atv;
      D.18969 = D.18968 / 10;
      D.18970 = (int) D.18969;
      step_3.38 = (long unsigned int) D.18970;
      step_5 = step_3.38;
      j = 0;
      max_xrefs = 0;
      max_entries = max_xrefs;
      i = 0;
      goto <D.18507>;
      <D.18506>:
      {
        struct SCC * scc;

        D.18989 = sccs.data;
        D.18990 = sccs.elem_size;
        D.18991 = D.18990 * i;
        D.18992 = (sizetype) D.18991;
        scc = D.18989 + D.18992;
        D.19060 = scc->num_bridge_entries;
        if (D.19060 != 0) goto <D.19061>; else goto <D.19062>;
        <D.19061>:
        j = j + 1;
        <D.19062>:
        D.19060 = scc->num_bridge_entries;
        if (D.19060 > max_entries) goto <D.19063>; else goto <D.19064>;
        <D.19063>:
        max_entries = scc->num_bridge_entries;
        <D.19064>:
        D.19065 = scc->xrefs.size;
        if (D.19065 > max_xrefs) goto <D.19066>; else goto <D.19067>;
        <D.19066>:
        max_xrefs = scc->xrefs.size;
        <D.19067>:
        D.19068 = &scc->xrefs;
        dyn_array_uninit (D.19068);
      }
      i = i + 1;
      <D.18507>:
      D.19007 = sccs.size;
      if (D.19007 > i) goto <D.18506>; else goto <D.18508>;
      <D.18508>:
      dyn_array_uninit (&sccs);
      D.18941 = hash_table.num_entries;
      D.18942 = (long unsigned int) D.18941;
      D.18943 = D.18942 * 8;
      sgen_free_internal_dynamic (all_entries, D.18943, 21);
      free_data ();
      num_registered_bridges = registered_bridges.size;
      registered_bridges.size = 0;
      atv = mono_100ns_ticks ();
      D.18985 = atv - btv;
      D.18986 = D.18985 / 10;
      D.18987 = (int) D.18986;
      step_4.44 = (long unsigned int) D.18987;
      step_6 = step_4.44;
      D.19069 = bridge_callbacks.cross_references;
      D.19069 (num_sccs, api_sccs, num_xrefs, api_xrefs);
      btv = mono_100ns_ticks ();
      D.18968 = btv - atv;
      D.18969 = D.18968 / 10;
      D.18970 = (int) D.18969;
      step_3.38 = (long unsigned int) D.18970;
      step_7 = step_3.38;
      i = 0;
      goto <D.18514>;
      <D.18513>:
      {
        unsigned char alive;

        try
          {
            D.18972 = (long unsigned int) i;
            D.18973 = D.18972 * 8;
            D.19070 = api_sccs + D.18973;
            D.19071 = *D.19070;
            D.19072 = D.19071->is_alive;
            D.19073 = D.19072 != 0;
            alive.50 = (unsigned char) D.19073;
            alive = alive.50;
            j = 0;
            goto <D.18511>;
            <D.18510>:
            D.18972 = (long unsigned int) i;
            D.18973 = D.18972 * 8;
            D.19070 = api_sccs + D.18973;
            D.19071 = *D.19070;
            D.19075 = D.19071->objs[j];
            sgen_hash_table_replace (&alive_hash, D.19075, &alive, 0B);
            D.18972 = (long unsigned int) i;
            D.18973 = D.18972 * 8;
            D.19070 = api_sccs + D.18973;
            D.19071 = *D.19070;
            D.19072 = D.19071->is_alive;
            if (D.19072 == 0) goto <D.19076>; else goto <D.19077>;
            <D.19076>:
            D.18972 = (long unsigned int) i;
            D.18973 = D.18972 * 8;
            D.19070 = api_sccs + D.18973;
            D.19071 = *D.19070;
            D.19075 = D.19071->objs[j];
            sgen_mark_bridge_object (D.19075);
            <D.19077>:
            j = j + 1;
            <D.18511>:
            D.18972 = (long unsigned int) i;
            D.18973 = D.18972 * 8;
            D.19070 = api_sccs + D.18973;
            D.19071 = *D.19070;
            D.19078 = D.19071->num_objs;
            if (D.19078 > j) goto <D.18510>; else goto <D.18512>;
            <D.18512>:
          }
        finally
          {
            alive = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18514>:
      if (i < num_sccs) goto <D.18513>; else goto <D.18515>;
      <D.18515>:
      sgen_null_links_with_predicate (0, is_bridge_object_alive, &alive_hash);
      if (generation == 1) goto <D.19079>; else goto <D.19080>;
      <D.19079>:
      sgen_null_links_with_predicate (1, is_bridge_object_alive, &alive_hash);
      <D.19080>:
      sgen_hash_table_clean (&alive_hash);
      i = 0;
      goto <D.18517>;
      <D.18516>:
      D.18972 = (long unsigned int) i;
      D.18973 = D.18972 * 8;
      D.19070 = api_sccs + D.18973;
      D.19071 = *D.19070;
      D.18972 = (long unsigned int) i;
      D.18973 = D.18972 * 8;
      D.19070 = api_sccs + D.18973;
      D.19071 = *D.19070;
      D.19078 = D.19071->num_objs;
      D.19081 = (long unsigned int) D.19078;
      D.19082 = D.19081 + 1;
      D.19083 = D.19082 * 8;
      sgen_free_internal_dynamic (D.19071, D.19083, 21);
      i = i + 1;
      <D.18517>:
      if (i < num_sccs) goto <D.18516>; else goto <D.18518>;
      <D.18518>:
      D.19008 = (long unsigned int) num_sccs;
      D.19009 = D.19008 * 8;
      sgen_free_internal_dynamic (api_sccs, D.19009, 21);
      D.19041 = (long unsigned int) num_xrefs;
      D.19042 = D.19041 * 8;
      sgen_free_internal_dynamic (api_xrefs, D.19042, 21);
      atv = mono_100ns_ticks ();
      D.18985 = atv - btv;
      D.18986 = D.18985 / 10;
      D.18987 = (int) D.18986;
      step_4.44 = (long unsigned int) D.18987;
      step_8 = step_4.44;
      D.19007 = sccs.size;
      step_1.51 = step_1;
      D.19085 = (float) step_1.51;
      D.19086 = D.19085 / 1.0e+3;
      D.19087 = (double) D.19086;
      step_2.52 = step_2;
      D.19089 = (float) step_2.52;
      D.19090 = D.19089 / 1.0e+3;
      D.19091 = (double) D.19090;
      step_3.53 = step_3;
      D.19093 = (float) step_3.53;
      D.19094 = D.19093 / 1.0e+3;
      D.19095 = (double) D.19094;
      step_4.54 = step_4;
      D.19097 = (float) step_4.54;
      D.19098 = D.19097 / 1.0e+3;
      D.19099 = (double) D.19098;
      step_5.55 = step_5;
      D.19101 = (float) step_5.55;
      D.19102 = D.19101 / 1.0e+3;
      D.19103 = (double) D.19102;
      step_6.56 = step_6;
      D.19105 = (float) step_6.56;
      D.19106 = D.19105 / 1.0e+3;
      D.19107 = (double) D.19106;
      step_7.57 = step_7;
      D.19109 = (float) step_7.57;
      D.19110 = D.19109 / 1.0e+3;
      D.19111 = (double) D.19110;
      step_8.58 = step_8;
      D.19113 = (float) step_8.58;
      D.19114 = D.19113 / 1.0e+3;
      D.19115 = (double) D.19114;
      fist_pass_links.35 = fist_pass_links;
      second_pass_links.42 = second_pass_links;
      sccs_links.45 = sccs_links;
      max_sccs_links.47 = max_sccs_links;
      dsf1_passes.59 = dsf1_passes;
      dsf2_passes.60 = dsf2_passes;
      mono_trace (64, 8, "GC_BRIDGE num-objects %d num_hash_entries %d sccs size %d init %.2fms df1 %.2fms sort %.2fms dfs2 %.2fms setup-cb %.2fms free-data %.2fms user-cb %.2fms clenanup %.2fms links %d/%d/%d/%d dfs passes %d/%d", num_registered_bridges, hash_table_size, D.19007, D.19087, D.19091, D.19095, D.19099, D.19103, D.19107, D.19111, D.19115, fist_pass_links.35, second_pass_links.42, sccs_links.45, max_sccs_links.47, dsf1_passes.59, dsf2_passes.60);
      step_1 = 0;
      bridge_processing_in_progress = 0;
    }
  finally
    {
      alive_hash = {CLOBBER};
    }
}


is_bridge_object_alive (struct MonoObject * obj, void * data)
{
  mono_bool D.19123;
  unsigned char D.19124;
  struct SgenHashTable * table;
  unsigned char * value;

  table = data;
  value = sgen_hash_table_lookup (table, obj);
  if (value == 0B) goto <D.19121>; else goto <D.19122>;
  <D.19121>:
  D.19123 = 1;
  return D.19123;
  <D.19122>:
  D.19124 = *value;
  D.19123 = (mono_bool) D.19124;
  return D.19123;
}


compare_hash_entries (const void * ep1, const void * ep2)
{
  int D.19126;
  int D.19127;
  int D.19128;
  struct HashEntry * e1;
  struct HashEntry * e2;

  e1 = MEM[(struct HashEntry * *)ep1];
  e2 = MEM[(struct HashEntry * *)ep2];
  D.19127 = e2->finishing_time;
  D.19128 = e1->finishing_time;
  D.19126 = D.19127 - D.19128;
  return D.19126;
}


dfs2 (struct HashEntry * entry)
{
  int D.19130;
  _Bool D.19131;
  long int D.19132;
  long int D.19133;
  int dsf2_passes.61;
  int dsf2_passes.62;
  int D.19138;
  struct SCC * current_scc.63;
  int D.19142;
  char * D.19145;
  int D.19146;
  int D.19147;
  sizetype D.19148;
  struct SCC * D.19149;
  char * D.19150;
  long unsigned int D.19151;
  long unsigned int D.19152;
  void * * D.19153;
  void * D.19154;
  int D.19155;
  int i;

  D.19130 = dfs_stack.size;
  D.19131 = D.19130 != 0;
  D.19132 = (long int) D.19131;
  D.19133 = __builtin_expect (D.19132, 0);
  if (D.19133 != 0) goto <D.19134>; else goto <D.19135>;
  <D.19134>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 501, "dfs_stack.size == 0");
  <D.19135>:
  dyn_array_ptr_add (&dfs_stack, entry);
  <D.18387>:
  entry = dyn_array_ptr_pop (&dfs_stack);
  dsf2_passes.61 = dsf2_passes;
  dsf2_passes.62 = dsf2_passes.61 + 1;
  dsf2_passes = dsf2_passes.62;
  D.19138 = entry->scc_index;
  if (D.19138 >= 0) goto <D.19139>; else goto <D.19140>;
  <D.19139>:
  D.19138 = entry->scc_index;
  current_scc.63 = current_scc;
  D.19142 = current_scc.63->index;
  if (D.19138 != D.19142) goto <D.19143>; else goto <D.19144>;
  <D.19143>:
  D.19145 = sccs.data;
  D.19138 = entry->scc_index;
  D.19146 = sccs.elem_size;
  D.19147 = D.19138 * D.19146;
  D.19148 = (sizetype) D.19147;
  D.19149 = D.19145 + D.19148;
  current_scc.63 = current_scc;
  scc_add_xref (D.19149, current_scc.63);
  <D.19144>:
  // predicted unlikely by continue predictor.
  goto <D.18383>;
  <D.19140>:
  current_scc.63 = current_scc;
  scc_add_entry (current_scc.63, entry);
  i = 0;
  goto <D.18385>;
  <D.18384>:
  D.19150 = entry->srcs.data;
  D.19151 = (long unsigned int) i;
  D.19152 = D.19151 * 8;
  D.19153 = D.19150 + D.19152;
  D.19154 = *D.19153;
  dyn_array_ptr_add (&dfs_stack, D.19154);
  i = i + 1;
  <D.18385>:
  D.19155 = entry->srcs.size;
  if (D.19155 > i) goto <D.18384>; else goto <D.18386>;
  <D.18386>:
  <D.18383>:
  D.19130 = dfs_stack.size;
  if (D.19130 > 0) goto <D.18387>; else goto <D.18388>;
  <D.18388>:
}


scc_add_xref (struct SCC * src, struct SCC * dst)
{
  _Bool D.19156;
  long int D.19157;
  long int D.19158;
  int D.19161;
  int D.19162;
  _Bool D.19163;
  long int D.19164;
  long int D.19165;
  struct DynArray * D.19168;
  int D.19169;
  int D.19172;
  struct DynArray * D.19176;
  char * D.19177;
  long unsigned int D.19178;
  long unsigned int D.19179;
  int * D.19180;
  int D.19181;
  _Bool D.19182;
  long int D.19183;
  long int D.19184;
  int D.19187;

  D.19156 = src == dst;
  D.19157 = (long int) D.19156;
  D.19158 = __builtin_expect (D.19157, 0);
  if (D.19158 != 0) goto <D.19159>; else goto <D.19160>;
  <D.19159>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 469, "src != dst");
  <D.19160>:
  D.19161 = src->index;
  D.19162 = dst->index;
  D.19163 = D.19161 == D.19162;
  D.19164 = (long int) D.19163;
  D.19165 = __builtin_expect (D.19164, 0);
  if (D.19165 != 0) goto <D.19166>; else goto <D.19167>;
  <D.19166>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 470, "src->index != dst->index");
  <D.19167>:
  D.19168 = &dst->xrefs;
  D.19161 = src->index;
  D.19169 = dyn_array_int_contains (D.19168, D.19161);
  if (D.19169 != 0) goto <D.19170>; else goto <D.19171>;
  <D.19170>:
  return;
  <D.19171>:
  D.19172 = src->num_bridge_entries;
  if (D.19172 != 0) goto <D.19173>; else goto <D.19174>;
  <D.19173>:
  D.19168 = &dst->xrefs;
  D.19161 = src->index;
  dyn_array_int_merge_one (D.19168, D.19161);
  goto <D.19175>;
  <D.19174>:
  {
    int i;

    D.19168 = &dst->xrefs;
    D.19176 = &src->xrefs;
    dyn_array_int_merge (D.19168, D.19176);
    i = 0;
    goto <D.18371>;
    <D.18370>:
    D.19177 = dst->xrefs.data;
    D.19178 = (long unsigned int) i;
    D.19179 = D.19178 * 4;
    D.19180 = D.19177 + D.19179;
    D.19181 = *D.19180;
    D.19162 = dst->index;
    D.19182 = D.19181 == D.19162;
    D.19183 = (long int) D.19182;
    D.19184 = __builtin_expect (D.19183, 0);
    if (D.19184 != 0) goto <D.19185>; else goto <D.19186>;
    <D.19185>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 480, "DYN_ARRAY_INT_REF (&dst->xrefs, i) != dst->index");
    <D.19186>:
    i = i + 1;
    <D.18371>:
    D.19187 = dst->xrefs.size;
    if (D.19187 > i) goto <D.18370>; else goto <D.18372>;
    <D.18372>:
  }
  <D.19175>:
}


dyn_array_int_contains (struct DynArray * da, int x)
{
  char * D.19189;
  long unsigned int D.19190;
  long unsigned int D.19191;
  int * D.19192;
  int D.19193;
  gboolean D.19196;
  int D.19197;
  int i;

  i = 0;
  goto <D.18151>;
  <D.18150>:
  D.19189 = da->data;
  D.19190 = (long unsigned int) i;
  D.19191 = D.19190 * 4;
  D.19192 = D.19189 + D.19191;
  D.19193 = *D.19192;
  if (D.19193 == x) goto <D.19194>; else goto <D.19195>;
  <D.19194>:
  D.19196 = 1;
  return D.19196;
  <D.19195>:
  i = i + 1;
  <D.18151>:
  D.19197 = da->size;
  if (D.19197 > i) goto <D.18150>; else goto <D.18152>;
  <D.18152>:
  D.19196 = 0;
  return D.19196;
}


dyn_array_int_merge_one (struct DynArray * array, int value)
{
  char * D.19199;
  long unsigned int D.19200;
  long unsigned int D.19201;
  int * D.19202;
  int D.19203;
  int D.19207;
  int D.19208;
  sizetype D.19211;
  sizetype D.19212;
  sizetype D.19213;
  int * D.19214;
  sizetype D.19215;
  sizetype D.19216;
  sizetype D.19217;
  int * D.19218;
  long unsigned int D.19220;
  long unsigned int D.19221;
  int * D.19222;
  int i;
  int tmp;
  int end;

  end = array->size;
  i = 0;
  goto <D.18174>;
  <D.18173>:
  D.19199 = array->data;
  D.19200 = (long unsigned int) i;
  D.19201 = D.19200 * 4;
  D.19202 = D.19199 + D.19201;
  D.19203 = *D.19202;
  if (D.19203 == value) goto <D.19204>; else goto <D.19205>;
  <D.19204>:
  return;
  <D.19205>:
  D.19199 = array->data;
  D.19200 = (long unsigned int) i;
  D.19201 = D.19200 * 4;
  D.19202 = D.19199 + D.19201;
  D.19203 = *D.19202;
  if (D.19203 > value) goto <D.18172>; else goto <D.19206>;
  <D.19206>:
  i = i + 1;
  <D.18174>:
  if (i < end) goto <D.18173>; else goto <D.18172>;
  <D.18172>:
  D.19207 = array->size;
  D.19208 = D.19207 + 1;
  dyn_array_ensure_capacity (array, D.19208);
  if (i < end) goto <D.19209>; else goto <D.19210>;
  <D.19209>:
  D.19199 = array->data;
  D.19200 = (long unsigned int) i;
  D.19201 = D.19200 * 4;
  D.19202 = D.19199 + D.19201;
  tmp = *D.19202;
  goto <D.18176>;
  <D.18175>:
  D.19199 = array->data;
  D.19200 = (long unsigned int) i;
  D.19201 = D.19200 * 4;
  D.19202 = D.19199 + D.19201;
  *D.19202 = value;
  value = tmp;
  D.19199 = array->data;
  D.19211 = (sizetype) i;
  D.19212 = D.19211 + 1;
  D.19213 = D.19212 * 4;
  D.19214 = D.19199 + D.19213;
  tmp = *D.19214;
  i = i + 1;
  <D.18176>:
  if (i <= end) goto <D.18175>; else goto <D.18177>;
  <D.18177>:
  D.19199 = array->data;
  D.19215 = (sizetype) end;
  D.19216 = D.19215 + 1;
  D.19217 = D.19216 * 4;
  D.19218 = D.19199 + D.19217;
  *D.19218 = tmp;
  goto <D.19219>;
  <D.19210>:
  D.19199 = array->data;
  D.19220 = (long unsigned int) end;
  D.19221 = D.19220 * 4;
  D.19222 = D.19199 + D.19221;
  *D.19222 = value;
  <D.19219>:
  D.19207 = array->size;
  D.19208 = D.19207 + 1;
  array->size = D.19208;
}


dyn_array_int_merge (struct DynArray * dst, struct DynArray * src)
{
  int D.19224;
  int D.19225;
  int D.19226;
  char * D.19231;
  long unsigned int D.19232;
  long unsigned int D.19233;
  int * D.19234;
  char * D.19235;
  long unsigned int D.19236;
  long unsigned int D.19237;
  int * D.19238;
  int D.19247;
  int D.19249;
  int D.19251;
  char * D.19254;
  int D.19255;
  int D.19256;
  long unsigned int D.19257;
  int i;
  int j;

  D.19224 = dst->size;
  D.19225 = src->size;
  D.19226 = D.19224 + D.19225;
  dyn_array_ensure_capacity (&merge_array, D.19226);
  merge_array.size = 0;
  j = 0;
  i = j;
  goto <D.18163>;
  <D.18162>:
  D.19224 = dst->size;
  if (D.19224 > i) goto <D.19229>; else goto <D.19227>;
  <D.19229>:
  D.19225 = src->size;
  if (D.19225 > j) goto <D.19230>; else goto <D.19227>;
  <D.19230>:
  {
    int a;
    int b;

    D.19231 = dst->data;
    D.19232 = (long unsigned int) i;
    D.19233 = D.19232 * 4;
    D.19234 = D.19231 + D.19233;
    a = *D.19234;
    D.19235 = src->data;
    D.19236 = (long unsigned int) j;
    D.19237 = D.19236 * 4;
    D.19238 = D.19235 + D.19237;
    b = *D.19238;
    if (a < b) goto <D.19239>; else goto <D.19240>;
    <D.19239>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    goto <D.19241>;
    <D.19240>:
    if (a == b) goto <D.19242>; else goto <D.19243>;
    <D.19242>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    j = j + 1;
    goto <D.19244>;
    <D.19243>:
    dyn_array_int_add (&merge_array, b);
    j = j + 1;
    <D.19244>:
    <D.19241>:
  }
  goto <D.19228>;
  <D.19227>:
  D.19224 = dst->size;
  if (D.19224 > i) goto <D.19245>; else goto <D.19246>;
  <D.19245>:
  D.19231 = dst->data;
  D.19232 = (long unsigned int) i;
  D.19233 = D.19232 * 4;
  D.19234 = D.19231 + D.19233;
  D.19247 = *D.19234;
  dyn_array_int_add (&merge_array, D.19247);
  i = i + 1;
  goto <D.19248>;
  <D.19246>:
  D.19235 = src->data;
  D.19236 = (long unsigned int) j;
  D.19237 = D.19236 * 4;
  D.19238 = D.19235 + D.19237;
  D.19249 = *D.19238;
  dyn_array_int_add (&merge_array, D.19249);
  j = j + 1;
  <D.19248>:
  <D.19228>:
  <D.18163>:
  D.19224 = dst->size;
  if (D.19224 > i) goto <D.18162>; else goto <D.19250>;
  <D.19250>:
  D.19225 = src->size;
  if (D.19225 > j) goto <D.18162>; else goto <D.18164>;
  <D.18164>:
  D.19251 = merge_array.size;
  D.19224 = dst->size;
  if (D.19251 > D.19224) goto <D.19252>; else goto <D.19253>;
  <D.19252>:
  D.19251 = merge_array.size;
  dyn_array_ensure_capacity (dst, D.19251);
  D.19231 = dst->data;
  D.19254 = merge_array.data;
  D.19251 = merge_array.size;
  D.19255 = merge_array.elem_size;
  D.19256 = D.19251 * D.19255;
  D.19257 = (long unsigned int) D.19256;
  memcpy (D.19231, D.19254, D.19257);
  D.19251 = merge_array.size;
  dst->size = D.19251;
  <D.19253>:
}


dyn_array_int_add (struct DynArray * da, int x)
{
  int * p;

  p = dyn_array_add (da);
  *p = x;
}


scc_add_entry (struct SCC * scc, struct HashEntry * entry)
{
  int D.19258;
  _Bool D.19259;
  long int D.19260;
  long int D.19261;
  int D.19264;
  int D.19265;
  int D.19268;
  int D.19269;

  D.19258 = entry->scc_index;
  D.19259 = D.19258 >= 0;
  D.19260 = (long int) D.19259;
  D.19261 = __builtin_expect (D.19260, 0);
  if (D.19261 != 0) goto <D.19262>; else goto <D.19263>;
  <D.19262>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 487, "entry->scc_index < 0");
  <D.19263>:
  D.19264 = scc->index;
  entry->scc_index = D.19264;
  D.19265 = entry->is_bridge;
  if (D.19265 != 0) goto <D.19266>; else goto <D.19267>;
  <D.19266>:
  D.19268 = scc->num_bridge_entries;
  D.19269 = D.19268 + 1;
  scc->num_bridge_entries = D.19269;
  <D.19267>:
}


dyn_array_uninit (struct DynArray * da)
{
  int D.19270;
  char * D.19273;
  int D.19274;
  int D.19275;
  long unsigned int D.19276;

  D.19270 = da->capacity;
  if (D.19270 <= 0) goto <D.19271>; else goto <D.19272>;
  <D.19271>:
  return;
  <D.19272>:
  D.19273 = da->data;
  D.19274 = da->elem_size;
  D.19270 = da->capacity;
  D.19275 = D.19274 * D.19270;
  D.19276 = (long unsigned int) D.19275;
  sgen_free_internal_dynamic (D.19273, D.19276, 21);
  da->data = 0B;
}


free_data ()
{
  long unsigned int D.19278;
  long unsigned int D.19279;
  int D.19280;
  struct DynArray * D.19283;
  struct SgenHashTableEntry * D.19284;
  unsigned int D.19285;
  struct MonoObject * obj;
  struct HashEntry * entry;
  int total_srcs;
  int max_srcs;

  total_srcs = 0;
  max_srcs = 0;
  {
    struct SgenHashTable * __hash_table;
    struct SgenHashTableEntry * * __table;
    guint __i;

    __hash_table = &hash_table;
    __table = __hash_table->table;
    __i = 0;
    goto <D.18239>;
    <D.18238>:
    {
      struct SgenHashTableEntry * * __iter;
      struct SgenHashTableEntry * * __next;

      D.19278 = (long unsigned int) __i;
      D.19279 = D.19278 * 8;
      __iter = __table + D.19279;
      goto <D.18236>;
      <D.18235>:
      {
        struct SgenHashTableEntry * __entry;

        __entry = *__iter;
        __next = &__entry->next;
        obj = __entry->key;
        entry = &__entry->data;
        D.19280 = entry->srcs.size;
        total_srcs = D.19280 + total_srcs;
        D.19280 = entry->srcs.size;
        if (D.19280 > max_srcs) goto <D.19281>; else goto <D.19282>;
        <D.19281>:
        max_srcs = entry->srcs.size;
        <D.19282>:
        D.19283 = &entry->srcs;
        dyn_array_uninit (D.19283);
      }
      __iter = __next;
      <D.18236>:
      D.19284 = *__iter;
      if (D.19284 != 0B) goto <D.18235>; else goto <D.18237>;
      <D.18237>:
    }
    __i = __i + 1;
    <D.18239>:
    D.19285 = hash_table.size;
    if (D.19285 > __i) goto <D.18238>; else goto <D.18240>;
    <D.18240>:
  }
  sgen_hash_table_clean (&hash_table);
  dyn_array_uninit (&merge_array);
}


sgen_bridge_describe_pointer (struct MonoObject * obj)
{
  char * D.19286;
  long unsigned int D.19287;
  long unsigned int D.19288;
  void * * D.19289;
  void * D.19290;
  int D.19293;
  int D.19296;
  int D.19297;
  struct HashEntry * entry;
  int i;

  i = 0;
  goto <D.18526>;
  <D.18525>:
  D.19286 = registered_bridges.data;
  D.19287 = (long unsigned int) i;
  D.19288 = D.19287 * 8;
  D.19289 = D.19286 + D.19288;
  D.19290 = *D.19289;
  if (D.19290 == obj) goto <D.19291>; else goto <D.19292>;
  <D.19291>:
  printf ("Pointer is a registered bridge object.\n");
  goto <D.18524>;
  <D.19292>:
  i = i + 1;
  <D.18526>:
  D.19293 = registered_bridges.size;
  if (D.19293 > i) goto <D.18525>; else goto <D.18524>;
  <D.18524>:
  entry = sgen_hash_table_lookup (&hash_table, obj);
  if (entry == 0B) goto <D.19294>; else goto <D.19295>;
  <D.19294>:
  return;
  <D.19295>:
  printf ("Bridge hash table entry %p:\n", entry);
  D.19296 = entry->is_bridge;
  printf ("  is bridge: %d\n", D.19296);
  D.19297 = entry->is_visited;
  printf ("  is visited: %d\n", D.19297);
}


printf (const char * restrict __fmt)
{
  int D.19299;

  D.19299 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.19299;
}


sgen_register_test_bridge_callbacks (const char * bridge_class_name)
{
  void (*<T2f74>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) iftmp.64;
  char D.19302;
  sizetype iftmp.65;
  const char * bridge_class.66;
  struct MonoGCBridgeCallbacks callbacks;

  try
    {
      callbacks.bridge_version = 3;
      callbacks.is_bridge_class = bridge_test_is_bridge_class;
      callbacks.is_bridge_object = bridge_test_is_bridge_object;
      D.19302 = *bridge_class_name;
      if (D.19302 == 50) goto <D.19303>; else goto <D.19304>;
      <D.19303>:
      iftmp.64 = bridge_test_cross_reference2;
      goto <D.19305>;
      <D.19304>:
      iftmp.64 = bridge_test_cross_reference;
      <D.19305>:
      callbacks.cross_references = iftmp.64;
      mono_gc_register_bridge_callbacks (&callbacks);
      D.19302 = *bridge_class_name;
      if (D.19302 == 50) goto <D.19307>; else goto <D.19308>;
      <D.19307>:
      iftmp.65 = 1;
      goto <D.19309>;
      <D.19308>:
      iftmp.65 = 0;
      <D.19309>:
      bridge_class.66 = bridge_class_name + iftmp.65;
      bridge_class = bridge_class.66;
    }
  finally
    {
      callbacks = {CLOBBER};
    }
}


bridge_test_cross_reference (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  int D.19311;
  long unsigned int D.19314;
  long unsigned int D.19315;
  struct MonoGCBridgeSCC * * D.19316;
  struct MonoGCBridgeSCC * D.19317;
  int D.19318;
  int iftmp.67;
  struct MonoGCBridgeXRef * D.19323;
  int D.19324;
  _Bool D.19326;
  long int D.19327;
  long int D.19328;
  int iftmp.68;
  int D.19335;
  _Bool D.19337;
  long int D.19338;
  long int D.19339;
  int i;

  i = 0;
  goto <D.18555>;
  <D.18554>:
  {
    int j;

    j = 0;
    goto <D.18552>;
    <D.18551>:
    D.19311 = i & 1;
    if (D.19311 != 0) goto <D.19312>; else goto <D.19313>;
    <D.19312>:
    D.19314 = (long unsigned int) i;
    D.19315 = D.19314 * 8;
    D.19316 = sccs + D.19315;
    D.19317 = *D.19316;
    D.19317->is_alive = 1;
    <D.19313>:
    j = j + 1;
    <D.18552>:
    D.19314 = (long unsigned int) i;
    D.19315 = D.19314 * 8;
    D.19316 = sccs + D.19315;
    D.19317 = *D.19316;
    D.19318 = D.19317->num_objs;
    if (D.19318 > j) goto <D.18551>; else goto <D.18553>;
    <D.18553>:
  }
  i = i + 1;
  <D.18555>:
  if (i < num_sccs) goto <D.18554>; else goto <D.18556>;
  <D.18556>:
  i = 0;
  goto <D.18558>;
  <D.18557>:
  D.19314 = (long unsigned int) i;
  D.19315 = D.19314 * 8;
  D.19323 = xrefs + D.19315;
  D.19324 = D.19323->src_scc_index;
  if (D.19324 < 0) goto <D.19320>; else goto <D.19325>;
  <D.19325>:
  D.19314 = (long unsigned int) i;
  D.19315 = D.19314 * 8;
  D.19323 = xrefs + D.19315;
  D.19324 = D.19323->src_scc_index;
  if (D.19324 >= num_sccs) goto <D.19320>; else goto <D.19321>;
  <D.19320>:
  iftmp.67 = 1;
  goto <D.19322>;
  <D.19321>:
  iftmp.67 = 0;
  <D.19322>:
  D.19326 = iftmp.67 != 0;
  D.19327 = (long int) D.19326;
  D.19328 = __builtin_expect (D.19327, 0);
  if (D.19328 != 0) goto <D.19329>; else goto <D.19330>;
  <D.19329>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 869, "xrefs [i].src_scc_index >= 0 && xrefs [i].src_scc_index < num_sccs");
  <D.19330>:
  D.19314 = (long unsigned int) i;
  D.19315 = D.19314 * 8;
  D.19323 = xrefs + D.19315;
  D.19335 = D.19323->dst_scc_index;
  if (D.19335 < 0) goto <D.19332>; else goto <D.19336>;
  <D.19336>:
  D.19314 = (long unsigned int) i;
  D.19315 = D.19314 * 8;
  D.19323 = xrefs + D.19315;
  D.19335 = D.19323->dst_scc_index;
  if (D.19335 >= num_sccs) goto <D.19332>; else goto <D.19333>;
  <D.19332>:
  iftmp.68 = 1;
  goto <D.19334>;
  <D.19333>:
  iftmp.68 = 0;
  <D.19334>:
  D.19337 = iftmp.68 != 0;
  D.19338 = (long int) D.19337;
  D.19339 = __builtin_expect (D.19338, 0);
  if (D.19339 != 0) goto <D.19340>; else goto <D.19341>;
  <D.19340>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 870, "xrefs [i].dst_scc_index >= 0 && xrefs [i].dst_scc_index < num_sccs");
  <D.19341>:
  i = i + 1;
  <D.18558>:
  if (i < num_xrefs) goto <D.18557>; else goto <D.18559>;
  <D.18559>:
}


bridge_test_cross_reference2 (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  struct MonoClassField * mono_bridge_test_field.69;
  struct MonoGCBridgeSCC * D.19345;
  struct MonoObject * D.19346;
  struct MonoClass * D.19347;
  struct MonoClassField * mono_bridge_test_field.70;
  _Bool D.19349;
  long int D.19350;
  long int D.19351;
  long unsigned int D.19354;
  long unsigned int D.19355;
  struct MonoGCBridgeSCC * * D.19356;
  struct MonoGCBridgeSCC * D.19357;
  int D.19358;
  int D.19361;
  int D.19364;
  struct MonoObject * D.19367;
  struct MonoGCBridgeXRef * D.19368;
  int D.19369;
  long unsigned int D.19370;
  long unsigned int D.19371;
  struct MonoGCBridgeSCC * * D.19372;
  struct MonoGCBridgeSCC * D.19373;
  int D.19374;
  int D.19377;
  long unsigned int D.19378;
  long unsigned int D.19379;
  struct MonoGCBridgeSCC * * D.19380;
  struct MonoGCBridgeSCC * D.19381;
  int D.19382;
  int i;
  gboolean modified;

  mono_bridge_test_field.69 = mono_bridge_test_field;
  if (mono_bridge_test_field.69 == 0B) goto <D.19343>; else goto <D.19344>;
  <D.19343>:
  D.19345 = *sccs;
  D.19346 = D.19345->objs[0];
  D.19347 = mono_object_get_class (D.19346);
  mono_bridge_test_field.70 = mono_class_get_field_from_name (D.19347, "__test");
  mono_bridge_test_field = mono_bridge_test_field.70;
  mono_bridge_test_field.69 = mono_bridge_test_field;
  D.19349 = mono_bridge_test_field.69 == 0B;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19352>; else goto <D.19353>;
  <D.19352>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 912, "mono_bridge_test_field");
  <D.19353>:
  <D.19344>:
  i = 0;
  goto <D.18599>;
  <D.18598>:
  {
    int j;
    gboolean live;

    live = 0;
    j = 0;
    goto <D.18592>;
    <D.18591>:
    D.19354 = (long unsigned int) i;
    D.19355 = D.19354 * 8;
    D.19356 = sccs + D.19355;
    D.19357 = *D.19356;
    D.19358 = test_scc (D.19357, j);
    if (D.19358 != 0) goto <D.19359>; else goto <D.19360>;
    <D.19359>:
    live = 1;
    goto <D.18590>;
    <D.19360>:
    j = j + 1;
    <D.18592>:
    D.19354 = (long unsigned int) i;
    D.19355 = D.19354 * 8;
    D.19356 = sccs + D.19355;
    D.19357 = *D.19356;
    D.19361 = D.19357->num_objs;
    if (D.19361 > j) goto <D.18591>; else goto <D.18590>;
    <D.18590>:
    if (live == 0) goto <D.19362>; else goto <D.19363>;
    <D.19362>:
    // predicted unlikely by continue predictor.
    goto <D.18593>;
    <D.19363>:
    j = 0;
    goto <D.18596>;
    <D.18595>:
    D.19354 = (long unsigned int) i;
    D.19355 = D.19354 * 8;
    D.19356 = sccs + D.19355;
    D.19357 = *D.19356;
    D.19364 = test_scc (D.19357, j);
    if (D.19364 == 0) goto <D.19365>; else goto <D.19366>;
    <D.19365>:
    {
      int status;

      try
        {
          status = 2;
          D.19354 = (long unsigned int) i;
          D.19355 = D.19354 * 8;
          D.19356 = sccs + D.19355;
          D.19357 = *D.19356;
          D.19367 = D.19357->objs[j];
          mono_bridge_test_field.69 = mono_bridge_test_field;
          mono_field_set_value (D.19367, mono_bridge_test_field.69, &status);
        }
      finally
        {
          status = {CLOBBER};
        }
    }
    <D.19366>:
    j = j + 1;
    <D.18596>:
    D.19354 = (long unsigned int) i;
    D.19355 = D.19354 * 8;
    D.19356 = sccs + D.19355;
    D.19357 = *D.19356;
    D.19361 = D.19357->num_objs;
    if (D.19361 > j) goto <D.18595>; else goto <D.18597>;
    <D.18597>:
  }
  <D.18593>:
  i = i + 1;
  <D.18599>:
  if (i < num_sccs) goto <D.18598>; else goto <D.18600>;
  <D.18600>:
  modified = 1;
  goto <D.18606>;
  <D.18605>:
  modified = 0;
  i = 0;
  goto <D.18603>;
  <D.18602>:
  {
    struct MonoGCBridgeXRef ref;

    try
      {
        D.19354 = (long unsigned int) i;
        D.19355 = D.19354 * 8;
        D.19368 = xrefs + D.19355;
        ref = *D.19368;
        D.19369 = ref.src_scc_index;
        D.19370 = (long unsigned int) D.19369;
        D.19371 = D.19370 * 8;
        D.19372 = sccs + D.19371;
        D.19373 = *D.19372;
        D.19374 = test_scc (D.19373, 0);
        if (D.19374 != 0) goto <D.19375>; else goto <D.19376>;
        <D.19375>:
        D.19377 = ref.dst_scc_index;
        D.19378 = (long unsigned int) D.19377;
        D.19379 = D.19378 * 8;
        D.19380 = sccs + D.19379;
        D.19381 = *D.19380;
        D.19382 = test_scc (D.19381, 0);
        if (D.19382 == 0) goto <D.19383>; else goto <D.19384>;
        <D.19383>:
        modified = 1;
        D.19377 = ref.dst_scc_index;
        D.19378 = (long unsigned int) D.19377;
        D.19379 = D.19378 * 8;
        D.19380 = sccs + D.19379;
        D.19381 = *D.19380;
        mark_scc (D.19381, 3);
        <D.19384>:
        <D.19376>:
      }
    finally
      {
        ref = {CLOBBER};
      }
  }
  i = i + 1;
  <D.18603>:
  if (i < num_xrefs) goto <D.18602>; else goto <D.18604>;
  <D.18604>:
  <D.18606>:
  if (modified != 0) goto <D.18605>; else goto <D.18607>;
  <D.18607>:
  i = 0;
  goto <D.18609>;
  <D.18608>:
  D.19354 = (long unsigned int) i;
  D.19355 = D.19354 * 8;
  D.19356 = sccs + D.19355;
  D.19357 = *D.19356;
  D.19357->is_alive = 1;
  i = i + 1;
  <D.18609>:
  if (i < num_sccs) goto <D.18608>; else goto <D.18610>;
  <D.18610>:
}


test_scc (struct MonoGCBridgeSCC * scc, int i)
{
  struct MonoObject * D.19385;
  struct MonoClassField * mono_bridge_test_field.71;
  gboolean D.19387;
  int status.72;
  _Bool D.19389;
  int status;

  try
    {
      status = 0;
      D.19385 = scc->objs[i];
      mono_bridge_test_field.71 = mono_bridge_test_field;
      mono_field_get_value (D.19385, mono_bridge_test_field.71, &status);
      status.72 = status;
      D.19389 = status.72 > 0;
      D.19387 = (gboolean) D.19389;
      return D.19387;
    }
  finally
    {
      status = {CLOBBER};
    }
}


mark_scc (struct MonoGCBridgeSCC * scc, int value)
{
  int D.19392;
  struct MonoObject * D.19395;
  struct MonoClassField * mono_bridge_test_field.73;
  int D.19397;
  int i;

  i = 0;
  goto <D.18578>;
  <D.18577>:
  D.19392 = test_scc (scc, i);
  if (D.19392 == 0) goto <D.19393>; else goto <D.19394>;
  <D.19393>:
  {
    int status;

    try
      {
        status = value;
        D.19395 = scc->objs[i];
        mono_bridge_test_field.73 = mono_bridge_test_field;
        mono_field_set_value (D.19395, mono_bridge_test_field.73, &status);
      }
    finally
      {
        status = {CLOBBER};
      }
  }
  <D.19394>:
  i = i + 1;
  <D.18578>:
  D.19397 = scc->num_objs;
  if (D.19397 > i) goto <D.18577>; else goto <D.18579>;
  <D.18579>:
}


bridge_test_is_bridge_object (struct MonoObject * object)
{
  gboolean D.19398;

  D.19398 = 1;
  return D.19398;
}


bridge_test_is_bridge_class (struct MonoClass * class)
{
  gboolean D.19400;
  int D.18539;
  const char * bridge_class.74;
  const char * D.19402;
  _Bool D.19403;

  {
    size_t __s1_len;
    size_t __s2_len;

    bridge_class.74 = bridge_class;
    D.19402 = class->name;
    D.18539 = __builtin_strcmp (bridge_class.74, D.19402);
  }
  D.19403 = D.18539 == 0;
  D.19400 = (gboolean) D.19403;
  return D.19400;
}