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.18222>; else goto <D.18223>;
  <D.18222>:
  return;
  <D.18223>:
  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.18225;

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


__attribute__((visibility ("hidden")))
sgen_is_bridge_object (struct MonoObject * obj)
{
  struct MonoVTable * D.18228;
  <unnamed-unsigned:4> D.18229;
  int D.18230;
  int D.18231;
  gboolean D.18234;
  mono_bool (*<T3021>) (struct MonoObject *) D.18235;

  D.18228 = obj->vtable;
  D.18229 = D.18228->gc_bits;
  D.18230 = (int) D.18229;
  D.18231 = D.18230 & 1;
  if (D.18231 == 0) goto <D.18232>; else goto <D.18233>;
  <D.18232>:
  D.18234 = 0;
  return D.18234;
  <D.18233>:
  D.18235 = bridge_callbacks.is_bridge_object;
  D.18234 = D.18235 (obj);
  return D.18234;
}


__attribute__((visibility ("hidden")))
sgen_is_bridge_class (struct MonoClass * class)
{
  gboolean D.18237;
  mono_bool (*<T301d>) (struct MonoClass *) D.18238;

  D.18238 = bridge_callbacks.is_bridge_class;
  D.18237 = D.18238 (class);
  return D.18237;
}


__attribute__((visibility ("hidden")))
sgen_need_bridge_processing ()
{
  gboolean D.18240;
  void (*<T302b>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.18241;
  _Bool D.18242;

  D.18241 = bridge_callbacks.cross_references;
  D.18242 = D.18241 != 0B;
  D.18240 = (gboolean) D.18242;
  return D.18240;
}


__attribute__((visibility ("hidden")))
sgen_bridge_register_finalized_object (struct MonoObject * obj)
{
  int D.18244;
  _Bool D.18245;
  long int D.18246;
  long int D.18247;

  D.18244 = sgen_need_bridge_processing ();
  D.18245 = D.18244 == 0;
  D.18246 = (long int) D.18245;
  D.18247 = __builtin_expect (D.18246, 0);
  if (D.18247 != 0) goto <D.18248>; else goto <D.18249>;
  <D.18248>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 537, "sgen_need_bridge_processing ()");
  <D.18249>:
  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.18250;
  int D.18251;
  char * D.18252;
  int D.18253;
  int D.18254;
  sizetype D.18255;
  void * D.18256;
  void * p;

  D.18250 = da->size;
  D.18251 = D.18250 + 1;
  dyn_array_ensure_capacity (da, D.18251);
  D.18252 = da->data;
  D.18250 = da->size;
  D.18253 = da->elem_size;
  D.18254 = D.18250 * D.18253;
  D.18255 = (sizetype) D.18254;
  p = D.18252 + D.18255;
  D.18250 = da->size;
  D.18251 = D.18250 + 1;
  da->size = D.18251;
  D.18256 = p;
  return D.18256;
}


dyn_array_ensure_capacity (struct DynArray * da, int capacity)
{
  int D.18260;
  int D.18263;
  int D.18264;
  int D.18265;
  long unsigned int D.18266;
  char * D.18267;
  int D.18268;
  int D.18269;
  long unsigned int D.18270;
  int D.18271;
  long unsigned int D.18272;
  int old_capacity;
  char * new_data;

  old_capacity = da->capacity;
  if (capacity <= old_capacity) goto <D.18258>; else goto <D.18259>;
  <D.18258>:
  return;
  <D.18259>:
  D.18260 = da->capacity;
  if (D.18260 == 0) goto <D.18261>; else goto <D.18262>;
  <D.18261>:
  da->capacity = 2;
  <D.18262>:
  goto <D.17739>;
  <D.17738>:
  D.18260 = da->capacity;
  D.18263 = D.18260 * 2;
  da->capacity = D.18263;
  <D.17739>:
  D.18260 = da->capacity;
  if (D.18260 < capacity) goto <D.17738>; else goto <D.17740>;
  <D.17740>:
  D.18264 = da->elem_size;
  D.18260 = da->capacity;
  D.18265 = D.18264 * D.18260;
  D.18266 = (long unsigned int) D.18265;
  new_data = sgen_alloc_internal_dynamic (D.18266, 21, 1);
  D.18267 = da->data;
  D.18264 = da->elem_size;
  D.18268 = da->size;
  D.18269 = D.18264 * D.18268;
  D.18270 = (long unsigned int) D.18269;
  memcpy (new_data, D.18267, D.18270);
  D.18267 = da->data;
  D.18264 = da->elem_size;
  D.18271 = D.18264 * old_capacity;
  D.18272 = (long unsigned int) D.18271;
  sgen_free_internal_dynamic (D.18267, D.18272, 21);
  da->data = new_data;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.18274;
  long unsigned int D.18275;

  D.18275 = __builtin_object_size (__dest, 0);
  D.18274 = __builtin___memcpy_chk (__dest, __src, __len, D.18275);
  return D.18274;
}


__attribute__((visibility ("hidden")))
sgen_bridge_reset_data ()
{
  registered_bridges.size = 0;
}


__attribute__((visibility ("hidden")))
sgen_bridge_processing_stw_step ()
{
  int D.18277;
  char * D.18280;
  long unsigned int D.18281;
  long unsigned int D.18282;
  void * * D.18283;
  void * D.18284;
  struct HashEntry * D.18285;
  long int D.18286;
  long int D.18287;
  int D.18288;
  long unsigned int D.18289;
  int i;
  gint64 atv;
  gint64 btv;

  D.18277 = registered_bridges.size;
  if (D.18277 == 0) goto <D.18278>; else goto <D.18279>;
  <D.18278>:
  return;
  <D.18279>:
  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.18034>;
  <D.18033>:
  D.18280 = registered_bridges.data;
  D.18281 = (long unsigned int) i;
  D.18282 = D.18281 * 8;
  D.18283 = D.18280 + D.18282;
  D.18284 = *D.18283;
  register_bridge_object (D.18284);
  i = i + 1;
  <D.18034>:
  D.18277 = registered_bridges.size;
  if (D.18277 > i) goto <D.18033>; else goto <D.18035>;
  <D.18035>:
  i = 0;
  goto <D.18037>;
  <D.18036>:
  D.18280 = registered_bridges.data;
  D.18281 = (long unsigned int) i;
  D.18282 = D.18281 * 8;
  D.18283 = D.18280 + D.18282;
  D.18284 = *D.18283;
  D.18285 = get_hash_entry (D.18284, 0B);
  dfs1 (D.18285, 0B);
  i = i + 1;
  <D.18037>:
  D.18277 = registered_bridges.size;
  if (D.18277 > i) goto <D.18036>; else goto <D.18038>;
  <D.18038>:
  atv = mono_100ns_ticks ();
  D.18286 = atv - btv;
  D.18287 = D.18286 / 10;
  D.18288 = (int) D.18287;
  D.18289 = (long unsigned int) D.18288;
  step_2 = D.18289;
}


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.18291;
  struct HashEntry * entry;

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


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

  try
    {
      entry = sgen_hash_table_lookup (&hash_table, obj);
      if (entry != 0B) goto <D.18293>; else goto <D.18294>;
      <D.18293>:
      if (existing != 0B) goto <D.18295>; else goto <D.18296>;
      <D.18295>:
      *existing = 1;
      <D.18296>:
      D.18297 = entry;
      return D.18297;
      <D.18294>:
      if (existing != 0B) goto <D.18298>; else goto <D.18299>;
      <D.18298>:
      *existing = 0;
      <D.18299>:
      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.18297 = sgen_hash_table_lookup (&hash_table, obj);
      return D.18297;
    }
  finally
    {
      new_entry = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.18302;
  long unsigned int D.18303;

  D.18303 = __builtin_object_size (__dest, 0);
  D.18302 = __builtin___memset_chk (__dest, __ch, __len, D.18303);
  return D.18302;
}


dfs1 (struct HashEntry * obj_entry, struct HashEntry * src)
{
  int D.18305;
  _Bool D.18306;
  long int D.18307;
  long int D.18308;
  int dsf1_passes.1;
  int D.18312;
  int D.18318;
  long unsigned int D.18321;
  long unsigned int D.18322;
  long unsigned int D.18323;
  long unsigned int D.18324;
  long unsigned int D.18327;
  long unsigned int D.18328;
  long unsigned int D.18329;
  long unsigned int D.18330;
  long unsigned int D.18331;
  long unsigned int D.18332;
  void * dst.2;
  struct MonoObject * dst.3;
  int D.18337;
  struct HashEntry * D.18340;
  struct MonoObject * dst.4;
  int D.18344;
  struct HashEntry * D.18347;
  long unsigned int D.18348;
  long unsigned int D.18349;
  int D.18350;
  void * dst.5;
  struct MonoObject * dst.6;
  int D.18355;
  struct HashEntry * D.18358;
  long unsigned int D.18359;
  long unsigned int D.18360;
  int D.18361;
  struct MonoObject * dst.7;
  int D.18365;
  struct HashEntry * D.18368;
  long unsigned int D.18369;
  long unsigned int D.18372;
  int D.18373;
  int D.18374;
  unsigned int D.18377;
  unsigned int el_size.8;
  unsigned int D.18379;
  sizetype D.18380;
  void * dst.9;
  struct MonoObject * dst.10;
  int D.18385;
  struct HashEntry * D.18388;
  int D.18392;
  int D.18393;
  long unsigned int D.18394;
  long unsigned int D.18395;
  long unsigned int D.18396;
  long unsigned int D.18397;
  void * * D.18398;
  void * dst.11;
  struct MonoObject * dst.12;
  int D.18403;
  struct HashEntry * D.18406;
  sizetype D.18407;
  long unsigned int D.18411;
  void * dst.13;
  struct MonoObject * dst.14;
  int D.18418;
  struct HashEntry * D.18421;
  long unsigned int D.18422;
  void * dst.15;
  struct MonoObject * dst.16;
  int D.18429;
  struct HashEntry * D.18432;
  long unsigned int D.18433;
  unsigned int D.18434;
  unsigned int D.18435;
  struct MonoVTable * D.18438;
  struct MonoClass * D.18439;
  const char * D.18440;
  const char * D.18441;
  gsize * bitmap_data.17;
  long unsigned int D.18443;
  void * dst.18;
  struct MonoObject * dst.19;
  int D.18450;
  struct HashEntry * D.18453;
  int bwords.20;
  long unsigned int D.18455;
  gsize * mbitmap_data.21;
  long unsigned int D.18457;
  unsigned int D.18458;
  unsigned int D.18459;
  struct MonoClass * D.18460;
  unsigned int el_size.22;
  unsigned int D.18462;
  sizetype D.18463;
  const char * D.18466;
  const char * D.18467;
  gsize * bitmap_data.23;
  long unsigned int D.18469;
  void * dst.24;
  struct MonoObject * dst.25;
  int D.18476;
  struct HashEntry * D.18479;
  unsigned int bwords.26;
  sizetype D.18481;
  int current_time.27;
  int current_time.28;
  int D.18485;

  D.18305 = dfs_stack.size;
  D.18306 = D.18305 != 0;
  D.18307 = (long int) D.18306;
  D.18308 = __builtin_expect (D.18307, 0);
  if (D.18308 != 0) goto <D.18309>; else goto <D.18310>;
  <D.18309>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 423, "dfs_stack.size == 0");
  <D.18310>:
  dyn_array_ptr_add (&dfs_stack, src);
  dyn_array_ptr_add (&dfs_stack, obj_entry);
  <D.17977>:
  {
    struct MonoObject * obj;
    char * start;

    dsf1_passes.1 = dsf1_passes;
    D.18312 = dsf1_passes.1 + 1;
    dsf1_passes = D.18312;
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    if (obj_entry != 0B) goto <D.18313>; else goto <D.18314>;
    <D.18313>:
    src = dyn_array_ptr_pop (&dfs_stack);
    obj = obj_entry->obj;
    start = obj;
    if (src != 0B) goto <D.18315>; else goto <D.18316>;
    <D.18315>:
    add_source (obj_entry, src);
    goto <D.18317>;
    <D.18316>:
    <D.18317>:
    D.18318 = obj_entry->is_visited;
    if (D.18318 != 0) goto <D.18319>; else goto <D.18320>;
    <D.18319>:
    // predicted unlikely by continue predictor.
    goto <D.17878>;
    <D.18320>:
    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.18321 = MEM[(mword *)start];
      D.18322 = D.18321 & 18446744073709551612;
      vt = (struct GCVTable *) D.18322;
      desc = vt->desc;
      D.18323 = desc & 7;
      switch (D.18323) <default: <D.17976>, case 1: <D.17881>, case 2: <D.17890>, case 3: <D.17940>, case 4: <D.17900>, case 5: <D.17933>, case 6: <D.17954>, case 7: <D.17975>>
      <D.17881>:
      D.18324 = desc & 4294901760;
      if (D.18324 != 0) goto <D.18325>; else goto <D.18326>;
      <D.18325>:
      {
        void * * _objptr_end;
        void * * _objptr;

        _objptr = start;
        D.18327 = desc >> 16;
        D.18328 = D.18327 & 255;
        D.18329 = D.18328 * 8;
        _objptr = _objptr + D.18329;
        D.18330 = desc >> 24;
        D.18331 = D.18330 & 255;
        D.18332 = D.18331 * 8;
        _objptr_end = _objptr + D.18332;
        {
          struct MonoObject * dst;

          try
            {
              dst.2 = *_objptr;
              dst = dst.2;
              dst.3 = dst;
              if (dst.3 != 0B) goto <D.18335>; else goto <D.18336>;
              <D.18335>:
              D.18337 = object_is_live (&dst);
              if (D.18337 == 0) goto <D.18338>; else goto <D.18339>;
              <D.18338>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.3 = dst;
              D.18340 = get_hash_entry (dst.3, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18340);
              <D.18339>:
              <D.18336>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 8;
        goto <D.17887>;
        <D.17886>:
        {
          struct MonoObject * dst;

          try
            {
              dst.2 = *_objptr;
              dst = dst.2;
              dst.4 = dst;
              if (dst.4 != 0B) goto <D.18342>; else goto <D.18343>;
              <D.18342>:
              D.18344 = object_is_live (&dst);
              if (D.18344 == 0) goto <D.18345>; else goto <D.18346>;
              <D.18345>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.4 = dst;
              D.18347 = get_hash_entry (dst.4, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18347);
              <D.18346>:
              <D.18343>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 8;
        <D.17887>:
        if (_objptr < _objptr_end) goto <D.17886>; else goto <D.17888>;
        <D.17888>:
      }
      <D.18326>:
      goto <D.17889>;
      <D.17890>:
      {
        void * * _objptr;
        gsize _bmap;

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

          _index = __builtin_ctzl (_bmap);
          D.18348 = (long unsigned int) _index;
          D.18349 = D.18348 * 8;
          _objptr = _objptr + D.18349;
          D.18350 = _index + 1;
          _bmap = _bmap >> D.18350;
          {
            struct MonoObject * dst;

            try
              {
                dst.5 = *_objptr;
                dst = dst.5;
                dst.6 = dst;
                if (dst.6 != 0B) goto <D.18353>; else goto <D.18354>;
                <D.18353>:
                D.18355 = object_is_live (&dst);
                if (D.18355 == 0) goto <D.18356>; else goto <D.18357>;
                <D.18356>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.6 = dst;
                D.18358 = get_hash_entry (dst.6, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18358);
                <D.18357>:
                <D.18354>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 8;
        }
        goto <D.17898>;
        <D.17897>:
        {
          int _index;

          _index = __builtin_ctzl (_bmap);
          D.18359 = (long unsigned int) _index;
          D.18360 = D.18359 * 8;
          _objptr = _objptr + D.18360;
          D.18361 = _index + 1;
          _bmap = _bmap >> D.18361;
          {
            struct MonoObject * dst;

            try
              {
                dst.5 = *_objptr;
                dst = dst.5;
                dst.7 = dst;
                if (dst.7 != 0B) goto <D.18363>; else goto <D.18364>;
                <D.18363>:
                D.18365 = object_is_live (&dst);
                if (D.18365 == 0) goto <D.18366>; else goto <D.18367>;
                <D.18366>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.7 = dst;
                D.18368 = get_hash_entry (dst.7, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18368);
                <D.18367>:
                <D.18364>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 8;
        }
        <D.17898>:
        if (_bmap != 0) goto <D.17897>; else goto <D.17899>;
        <D.17899>:
      }
      goto <D.17889>;
      <D.17900>:
      D.18369 = desc & 4294950912;
      if (D.18369 != 0) goto <D.18370>; else goto <D.18371>;
      <D.18370>:
      {
        int el_size;
        int etype;

        D.18372 = desc >> 3;
        D.18373 = (int) D.18372;
        el_size = D.18373 & 1023;
        D.18374 = (int) desc;
        etype = D.18374 & 49152;
        if (etype == 16384) goto <D.18375>; else goto <D.18376>;
        <D.18375>:
        {
          void * * p;
          void * * end_refs;

          p = start + 32;
          D.18377 = MEM[(struct MonoArray *)start].max_length;
          el_size.8 = (unsigned int) el_size;
          D.18379 = D.18377 * el_size.8;
          D.18380 = (sizetype) D.18379;
          end_refs = p + D.18380;
          goto <D.17907>;
          <D.17906>:
          {
            struct MonoObject * dst;

            try
              {
                dst.9 = *p;
                dst = dst.9;
                dst.10 = dst;
                if (dst.10 != 0B) goto <D.18383>; else goto <D.18384>;
                <D.18383>:
                D.18385 = object_is_live (&dst);
                if (D.18385 == 0) goto <D.18386>; else goto <D.18387>;
                <D.18386>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.10 = dst;
                D.18388 = get_hash_entry (dst.10, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18388);
                <D.18387>:
                <D.18384>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          p = p + 8;
          <D.17907>:
          if (p < end_refs) goto <D.17906>; else goto <D.17908>;
          <D.17908>:
        }
        goto <D.18389>;
        <D.18376>:
        if (etype == 32768) goto <D.18390>; else goto <D.18391>;
        <D.18390>:
        {
          int offset;
          int num_refs;
          char * e_start;
          char * e_end;

          D.18327 = desc >> 16;
          D.18392 = (int) D.18327;
          offset = D.18392 & 255;
          D.18330 = desc >> 24;
          D.18393 = (int) D.18330;
          num_refs = D.18393 & 255;
          e_start = start + 32;
          D.18377 = MEM[(struct MonoArray *)start].max_length;
          el_size.8 = (unsigned int) el_size;
          D.18379 = D.18377 * el_size.8;
          D.18380 = (sizetype) D.18379;
          e_end = e_start + D.18380;
          goto <D.17920>;
          <D.17919>:
          {
            void * * p;
            int i;

            p = e_start;
            D.18394 = (long unsigned int) offset;
            D.18395 = D.18394 * 8;
            p = p + D.18395;
            i = 0;
            goto <D.17917>;
            <D.17916>:
            {
              struct MonoObject * dst;

              try
                {
                  D.18396 = (long unsigned int) i;
                  D.18397 = D.18396 * 8;
                  D.18398 = p + D.18397;
                  dst.11 = *D.18398;
                  dst = dst.11;
                  dst.12 = dst;
                  if (dst.12 != 0B) goto <D.18401>; else goto <D.18402>;
                  <D.18401>:
                  D.18403 = object_is_live (&dst);
                  if (D.18403 == 0) goto <D.18404>; else goto <D.18405>;
                  <D.18404>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.12 = dst;
                  D.18406 = get_hash_entry (dst.12, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18406);
                  <D.18405>:
                  <D.18402>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            i = i + 1;
            <D.17917>:
            if (i < num_refs) goto <D.17916>; else goto <D.17918>;
            <D.17918>:
            D.18407 = (sizetype) el_size;
            e_start = e_start + D.18407;
          }
          <D.17920>:
          if (e_start < e_end) goto <D.17919>; else goto <D.17921>;
          <D.17921>:
        }
        goto <D.18408>;
        <D.18391>:
        if (etype == 49152) goto <D.18409>; else goto <D.18410>;
        <D.18409>:
        {
          char * e_start;
          char * e_end;

          e_start = start + 32;
          D.18377 = MEM[(struct MonoArray *)start].max_length;
          el_size.8 = (unsigned int) el_size;
          D.18379 = D.18377 * el_size.8;
          D.18380 = (sizetype) D.18379;
          e_end = e_start + D.18380;
          goto <D.17931>;
          <D.17930>:
          {
            void * * p;
            gsize _bmap;

            p = e_start;
            _bmap = desc >> 16;
            goto <D.17928>;
            <D.17927>:
            D.18411 = _bmap & 1;
            if (D.18411 != 0) goto <D.18412>; else goto <D.18413>;
            <D.18412>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.13 = *p;
                  dst = dst.13;
                  dst.14 = dst;
                  if (dst.14 != 0B) goto <D.18416>; else goto <D.18417>;
                  <D.18416>:
                  D.18418 = object_is_live (&dst);
                  if (D.18418 == 0) goto <D.18419>; else goto <D.18420>;
                  <D.18419>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.14 = dst;
                  D.18421 = get_hash_entry (dst.14, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18421);
                  <D.18420>:
                  <D.18417>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.18413>:
            _bmap = _bmap >> 1;
            p = p + 8;
            <D.17928>:
            if (_bmap != 0) goto <D.17927>; else goto <D.17929>;
            <D.17929>:
            D.18407 = (sizetype) el_size;
            e_start = e_start + D.18407;
          }
          <D.17931>:
          if (e_start < e_end) goto <D.17930>; else goto <D.17932>;
          <D.17932>:
        }
        <D.18410>:
        <D.18408>:
        <D.18389>:
      }
      <D.18371>:
      goto <D.17889>;
      <D.17933>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 3;
        _objptr = _objptr + 16;
        goto <D.17938>;
        <D.17937>:
        D.18422 = _bmap & 1;
        if (D.18422 != 0) goto <D.18423>; else goto <D.18424>;
        <D.18423>:
        {
          struct MonoObject * dst;

          try
            {
              dst.15 = *_objptr;
              dst = dst.15;
              dst.16 = dst;
              if (dst.16 != 0B) goto <D.18427>; else goto <D.18428>;
              <D.18427>:
              D.18429 = object_is_live (&dst);
              if (D.18429 == 0) goto <D.18430>; else goto <D.18431>;
              <D.18430>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.16 = dst;
              D.18432 = get_hash_entry (dst.16, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18432);
              <D.18431>:
              <D.18428>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        <D.18424>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.17938>:
        if (_bmap != 0) goto <D.17937>; else goto <D.17939>;
        <D.17939>:
      }
      goto <D.17889>;
      <D.17940>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        int bwords;
        void * * start_run;

        _objptr = start;
        bitmap_data = sgen_get_complex_descriptor (desc);
        D.18433 = *bitmap_data;
        D.18434 = (unsigned int) D.18433;
        D.18435 = D.18434 + 4294967295;
        bwords = (int) D.18435;
        start_run = _objptr;
        bitmap_data = bitmap_data + 8;
        if (0 != 0) goto <D.18436>; else goto <D.18437>;
        <D.18436>:
        {
          struct MonoObject * myobj;

          myobj = start;
          D.18438 = myobj->vtable;
          D.18439 = D.18438->klass;
          D.18440 = D.18439->name_space;
          D.18438 = myobj->vtable;
          D.18439 = D.18438->klass;
          D.18441 = D.18439->name;
          monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18440, D.18441);
        }
        <D.18437>:
        goto <D.17952>;
        <D.17951>:
        {
          gsize _bmap;

          bitmap_data.17 = bitmap_data;
          bitmap_data = bitmap_data.17 + 8;
          _bmap = *bitmap_data.17;
          _objptr = start_run;
          goto <D.17949>;
          <D.17948>:
          D.18443 = _bmap & 1;
          if (D.18443 != 0) goto <D.18444>; else goto <D.18445>;
          <D.18444>:
          {
            struct MonoObject * dst;

            try
              {
                dst.18 = *_objptr;
                dst = dst.18;
                dst.19 = dst;
                if (dst.19 != 0B) goto <D.18448>; else goto <D.18449>;
                <D.18448>:
                D.18450 = object_is_live (&dst);
                if (D.18450 == 0) goto <D.18451>; else goto <D.18452>;
                <D.18451>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.19 = dst;
                D.18453 = get_hash_entry (dst.19, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18453);
                <D.18452>:
                <D.18449>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          <D.18445>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.17949>:
          if (_bmap != 0) goto <D.17948>; else goto <D.17950>;
          <D.17950>:
          start_run = start_run + 512;
        }
        <D.17952>:
        bwords.20 = bwords;
        bwords = bwords.20 + -1;
        if (bwords.20 > 0) goto <D.17951>; else goto <D.17953>;
        <D.17953>:
      }
      goto <D.17889>;
      <D.17954>:
      {
        gsize * mbitmap_data;
        int mbwords;
        int el_size;
        char * e_start;
        char * e_end;

        D.18455 = vt->desc;
        mbitmap_data = sgen_get_complex_descriptor (D.18455);
        mbitmap_data.21 = mbitmap_data;
        mbitmap_data = mbitmap_data.21 + 8;
        D.18457 = *mbitmap_data.21;
        D.18458 = (unsigned int) D.18457;
        D.18459 = D.18458 + 4294967295;
        mbwords = (int) D.18459;
        D.18460 = vt->klass;
        el_size = mono_array_element_size (D.18460);
        e_start = start + 32;
        D.18377 = MEM[(struct MonoArray *)start].max_length;
        el_size.22 = (unsigned int) el_size;
        D.18462 = D.18377 * el_size.22;
        D.18463 = (sizetype) D.18462;
        e_end = e_start + D.18463;
        if (0 != 0) goto <D.18464>; else goto <D.18465>;
        <D.18464>:
        D.18455 = vt->desc;
        D.18460 = vt->klass;
        D.18466 = D.18460->name_space;
        D.18460 = vt->klass;
        D.18467 = D.18460->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18455, D.18466, D.18467);
        <D.18465>:
        goto <D.17973>;
        <D.17972>:
        {
          void * * _objptr;
          gsize * bitmap_data;
          unsigned int bwords;

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

            bitmap_data.23 = bitmap_data;
            bitmap_data = bitmap_data.23 + 8;
            _bmap = *bitmap_data.23;
            start_run = _objptr;
            goto <D.17967>;
            <D.17966>:
            D.18469 = _bmap & 1;
            if (D.18469 != 0) goto <D.18470>; else goto <D.18471>;
            <D.18470>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.24 = *_objptr;
                  dst = dst.24;
                  dst.25 = dst;
                  if (dst.25 != 0B) goto <D.18474>; else goto <D.18475>;
                  <D.18474>:
                  D.18476 = object_is_live (&dst);
                  if (D.18476 == 0) goto <D.18477>; else goto <D.18478>;
                  <D.18477>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.25 = dst;
                  D.18479 = get_hash_entry (dst.25, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18479);
                  <D.18478>:
                  <D.18475>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.18471>:
            _bmap = _bmap >> 1;
            _objptr = _objptr + 8;
            <D.17967>:
            if (_bmap != 0) goto <D.17966>; else goto <D.17968>;
            <D.17968>:
            _objptr = start_run + 512;
          }
          <D.17970>:
          bwords.26 = bwords;
          bwords = bwords.26 + 4294967295;
          if (bwords.26 != 0) goto <D.17969>; else goto <D.17971>;
          <D.17971>:
          D.18481 = (sizetype) el_size;
          e_start = e_start + D.18481;
        }
        <D.17973>:
        if (e_start < e_end) goto <D.17972>; else goto <D.17974>;
        <D.17974>:
      }
      goto <D.17889>;
      <D.17975>:
      goto <D.17889>;
      <D.17976>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
      <D.17889>:
    }
    goto <D.18482>;
    <D.18314>:
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    current_time.27 = current_time;
    current_time.28 = current_time.27;
    D.18485 = current_time.28 + 1;
    current_time = D.18485;
    register_finishing_time (obj_entry, current_time.28);
    <D.18482>:
  }
  <D.17878>:
  D.18305 = dfs_stack.size;
  if (D.18305 > 0) goto <D.17977>; else goto <D.17978>;
  <D.17978>:
}


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

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


object_is_live (struct MonoObject * * objp)
{
  struct MonoObject * iftmp.29;
  long unsigned int D.18490;
  long unsigned int D.18491;
  long unsigned int D.18494;
  gboolean D.18498;
  void * D.18499;
  _Bool D.18500;
  int D.18501;
  void * D.18504;
  _Bool D.18505;
  struct MonoObject * obj;
  struct MonoObject * fwd;

  obj = *objp;
  D.18490 = MEM[(mword *)obj];
  D.18491 = D.18490 & 1;
  if (D.18491 != 0) goto <D.18492>; else goto <D.18493>;
  <D.18492>:
  D.18490 = MEM[(mword *)obj];
  D.18494 = D.18490 & 18446744073709551612;
  iftmp.29 = (struct MonoObject *) D.18494;
  goto <D.18495>;
  <D.18493>:
  iftmp.29 = 0B;
  <D.18495>:
  fwd = iftmp.29;
  if (fwd != 0B) goto <D.18496>; else goto <D.18497>;
  <D.18496>:
  *objp = fwd;
  D.18499 = sgen_hash_table_lookup (&hash_table, fwd);
  D.18500 = D.18499 == 0B;
  D.18498 = (gboolean) D.18500;
  return D.18498;
  <D.18497>:
  D.18501 = sgen_object_is_live (obj);
  if (D.18501 == 0) goto <D.18502>; else goto <D.18503>;
  <D.18502>:
  D.18498 = 0;
  return D.18498;
  <D.18503>:
  D.18504 = sgen_hash_table_lookup (&hash_table, obj);
  D.18505 = D.18504 == 0B;
  D.18498 = (gboolean) D.18505;
  return D.18498;
}


dyn_array_ptr_pop (struct DynArray * da)
{
  int D.18507;
  _Bool D.18508;
  long int D.18509;
  long int D.18510;
  char * D.18513;
  long unsigned int D.18514;
  long unsigned int D.18515;
  sizetype D.18516;
  void * * D.18517;
  int D.18518;
  void * D.18519;
  void * p;

  D.18507 = da->size;
  D.18508 = D.18507 <= 0;
  D.18509 = (long int) D.18508;
  D.18510 = __builtin_expect (D.18509, 0);
  if (D.18510 != 0) goto <D.18511>; else goto <D.18512>;
  <D.18511>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 142, "da->size > 0");
  <D.18512>:
  D.18513 = da->data;
  D.18507 = da->size;
  D.18514 = (long unsigned int) D.18507;
  D.18515 = D.18514 * 8;
  D.18516 = D.18515 + 18446744073709551608;
  D.18517 = D.18513 + D.18516;
  p = *D.18517;
  D.18507 = da->size;
  D.18518 = D.18507 + -1;
  da->size = D.18518;
  D.18519 = p;
  return D.18519;
}


register_finishing_time (struct HashEntry * entry, int t)
{
  int D.18521;
  _Bool D.18522;
  long int D.18523;
  long int D.18524;

  D.18521 = entry->finishing_time;
  D.18522 = D.18521 >= 0;
  D.18523 = (long int) D.18522;
  D.18524 = __builtin_expect (D.18523, 0);
  if (D.18524 != 0) goto <D.18525>; else goto <D.18526>;
  <D.18525>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 387, "entry->finishing_time < 0");
  <D.18526>:
  entry->finishing_time = t;
}


__attribute__((visibility ("hidden")))
sgen_bridge_processing_finish (int generation)
{
  int D.18528;
  int bridge_processing_in_progress.30;
  _Bool D.18532;
  long int D.18533;
  long int D.18534;
  unsigned int D.18537;
  long unsigned int D.18538;
  long unsigned int D.18539;
  long unsigned int D.18540;
  long unsigned int D.18541;
  int D.18542;
  _Bool D.18543;
  long int D.18544;
  long int D.18545;
  int j.31;
  long unsigned int D.18549;
  long unsigned int D.18550;
  struct HashEntry * * D.18551;
  int D.18552;
  int fist_pass_links.32;
  int D.18554;
  struct SgenHashTableEntry * D.18555;
  unsigned int D.18556;
  unsigned int j.33;
  _Bool D.18558;
  long int D.18559;
  long int D.18560;
  long unsigned int D.18563;
  long int D.18564;
  long int D.18565;
  int D.18566;
  long unsigned int D.18567;
  long unsigned int D.18568;
  long unsigned int D.18569;
  struct HashEntry * * D.18570;
  int D.18571;
  void * D.18574;
  struct SCC * current_scc.34;
  struct DynArray * D.18576;
  unsigned int i.35;
  int D.18578;
  int second_pass_links.36;
  int D.18580;
  long int D.18581;
  long int D.18582;
  int D.18583;
  long unsigned int D.18584;
  char * D.18585;
  int D.18586;
  int D.18587;
  sizetype D.18588;
  int D.18589;
  _Bool D.18590;
  long int D.18591;
  long int D.18592;
  int D.18595;
  int D.18598;
  int sccs_links.37;
  int D.18600;
  int max_sccs_links.38;
  int D.18602;
  int D.18603;
  long unsigned int D.18604;
  long unsigned int D.18605;
  int D.18606;
  long unsigned int D.18609;
  long unsigned int D.18610;
  struct MonoGCBridgeSCC * * D.18611;
  long unsigned int D.18612;
  long unsigned int D.18613;
  long unsigned int D.18614;
  void * D.18615;
  struct MonoGCBridgeSCC * D.18616;
  int j.39;
  int D.18618;
  long unsigned int D.18619;
  long unsigned int D.18620;
  int D.18621;
  int D.18624;
  int D.18625;
  sizetype D.18626;
  int D.18627;
  long unsigned int D.18628;
  long unsigned int D.18629;
  struct MonoGCBridgeSCC * * D.18630;
  struct MonoGCBridgeSCC * D.18631;
  int D.18632;
  int D.18633;
  int D.18634;
  struct MonoObject * D.18635;
  struct SgenHashTableEntry * D.18636;
  long unsigned int D.18637;
  long unsigned int D.18638;
  int D.18639;
  char * D.18642;
  long unsigned int D.18643;
  long unsigned int D.18644;
  int * D.18645;
  int D.18646;
  int D.18647;
  sizetype D.18648;
  int D.18649;
  struct MonoGCBridgeXRef * D.18652;
  int D.18653;
  int D.18654;
  int D.18655;
  int D.18656;
  int D.18661;
  struct DynArray * D.18664;
  void (*<T302b>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.18665;
  struct MonoGCBridgeSCC * * D.18666;
  struct MonoGCBridgeSCC * D.18667;
  int D.18668;
  _Bool D.18669;
  unsigned char alive.40;
  struct MonoObject * D.18671;
  int D.18674;
  long unsigned int D.18677;
  long unsigned int D.18678;
  long unsigned int D.18679;
  long unsigned int step_1.41;
  float D.18681;
  float D.18682;
  double D.18683;
  long unsigned int step_2.42;
  float D.18685;
  float D.18686;
  double D.18687;
  long unsigned int step_3.43;
  float D.18689;
  float D.18690;
  double D.18691;
  long unsigned int step_4.44;
  float D.18693;
  float D.18694;
  double D.18695;
  long unsigned int step_5.45;
  float D.18697;
  float D.18698;
  double D.18699;
  long unsigned int step_6.46;
  float D.18701;
  float D.18702;
  double D.18703;
  long unsigned int step_7.47;
  float D.18705;
  float D.18706;
  double D.18707;
  long unsigned int step_8.48;
  float D.18709;
  float D.18710;
  double D.18711;
  int dsf1_passes.49;
  int dsf2_passes.50;
  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.18528 = registered_bridges.size;
      if (D.18528 == 0) goto <D.18529>; else goto <D.18530>;
      <D.18529>:
      return;
      <D.18530>:
      bridge_processing_in_progress.30 = bridge_processing_in_progress;
      D.18532 = bridge_processing_in_progress.30 == 0;
      D.18533 = (long int) D.18532;
      D.18534 = __builtin_expect (D.18533, 0);
      if (D.18534 != 0) goto <D.18535>; else goto <D.18536>;
      <D.18535>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 620, "bridge_processing_in_progress");
      <D.18536>:
      atv = mono_100ns_ticks ();
      D.18537 = hash_table.num_entries;
      D.18538 = (long unsigned int) D.18537;
      D.18539 = D.18538 * 8;
      all_entries = sgen_alloc_internal_dynamic (D.18539, 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.18075>;
        <D.18074>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.18540 = (long unsigned int) __i;
          D.18541 = D.18540 * 8;
          __iter = __table + D.18541;
          goto <D.18072>;
          <D.18071>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.18542 = entry->finishing_time;
            D.18543 = D.18542 < 0;
            D.18544 = (long int) D.18543;
            D.18545 = __builtin_expect (D.18544, 0);
            if (D.18545 != 0) goto <D.18546>; else goto <D.18547>;
            <D.18546>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 630, "entry->finishing_time >= 0");
            <D.18547>:
            j.31 = j;
            j = j.31 + 1;
            D.18549 = (long unsigned int) j.31;
            D.18550 = D.18549 * 8;
            D.18551 = all_entries + D.18550;
            *D.18551 = entry;
            D.18552 = entry->srcs.size;
            fist_pass_links.32 = fist_pass_links;
            D.18554 = D.18552 + fist_pass_links.32;
            fist_pass_links = D.18554;
          }
          __iter = __next;
          <D.18072>:
          D.18555 = *__iter;
          if (D.18555 != 0B) goto <D.18071>; else goto <D.18073>;
          <D.18073>:
        }
        __i = __i + 1;
        <D.18075>:
        D.18556 = hash_table.size;
        if (D.18556 > __i) goto <D.18074>; else goto <D.18076>;
        <D.18076>:
      }
      D.18537 = hash_table.num_entries;
      j.33 = (unsigned int) j;
      D.18558 = D.18537 != j.33;
      D.18559 = (long int) D.18558;
      D.18560 = __builtin_expect (D.18559, 0);
      if (D.18560 != 0) goto <D.18561>; else goto <D.18562>;
      <D.18561>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 634, "j == hash_table.num_entries");
      <D.18562>:
      D.18537 = hash_table.num_entries;
      hash_table_size = (int) D.18537;
      D.18537 = hash_table.num_entries;
      D.18563 = (long unsigned int) D.18537;
      sgen_qsort (all_entries, D.18563, 8, compare_hash_entries);
      btv = mono_100ns_ticks ();
      D.18564 = btv - atv;
      D.18565 = D.18564 / 10;
      D.18566 = (int) D.18565;
      D.18567 = (long unsigned int) D.18566;
      step_3 = D.18567;
      dyn_array_init (&sccs, 40);
      i = 0;
      goto <D.18080>;
      <D.18079>:
      {
        struct HashEntry * entry;

        D.18568 = (long unsigned int) i;
        D.18569 = D.18568 * 8;
        D.18570 = all_entries + D.18569;
        entry = *D.18570;
        D.18571 = entry->scc_index;
        if (D.18571 < 0) goto <D.18572>; else goto <D.18573>;
        <D.18572>:
        {
          int index;

          index = sccs.size;
          D.18574 = dyn_array_add (&sccs);
          current_scc = D.18574;
          current_scc.34 = current_scc;
          current_scc.34->index = index;
          current_scc.34 = current_scc;
          current_scc.34->num_bridge_entries = 0;
          current_scc.34 = current_scc;
          current_scc.34->api_index = -1;
          current_scc.34 = current_scc;
          D.18576 = &current_scc.34->xrefs;
          dyn_array_int_init (D.18576);
          dfs2 (entry);
        }
        <D.18573>:
      }
      i = i + 1;
      <D.18080>:
      D.18537 = hash_table.num_entries;
      i.35 = (unsigned int) i;
      if (D.18537 > i.35) goto <D.18079>; else goto <D.18081>;
      <D.18081>:
      sccs_size = sccs.size;
      i = 0;
      goto <D.18084>;
      <D.18083>:
      {
        struct HashEntry * entry;

        D.18568 = (long unsigned int) i;
        D.18569 = D.18568 * 8;
        D.18570 = all_entries + D.18569;
        entry = *D.18570;
        D.18578 = entry->srcs.size;
        second_pass_links.36 = second_pass_links;
        D.18580 = D.18578 + second_pass_links.36;
        second_pass_links = D.18580;
      }
      i = i + 1;
      <D.18084>:
      D.18537 = hash_table.num_entries;
      i.35 = (unsigned int) i;
      if (D.18537 > i.35) goto <D.18083>; else goto <D.18085>;
      <D.18085>:
      atv = mono_100ns_ticks ();
      D.18581 = atv - btv;
      D.18582 = D.18581 / 10;
      D.18583 = (int) D.18582;
      D.18584 = (long unsigned int) D.18583;
      step_4 = D.18584;
      dyn_array_uninit (&dfs_stack);
      num_sccs = 0;
      i = 0;
      goto <D.18088>;
      <D.18087>:
      {
        struct SCC * scc;

        D.18585 = sccs.data;
        D.18586 = sccs.elem_size;
        D.18587 = D.18586 * i;
        D.18588 = (sizetype) D.18587;
        scc = D.18585 + D.18588;
        D.18589 = scc->index;
        D.18590 = D.18589 != i;
        D.18591 = (long int) D.18590;
        D.18592 = __builtin_expect (D.18591, 0);
        if (D.18592 != 0) goto <D.18593>; else goto <D.18594>;
        <D.18593>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 680, "scc->index == i");
        <D.18594>:
        D.18595 = scc->num_bridge_entries;
        if (D.18595 != 0) goto <D.18596>; else goto <D.18597>;
        <D.18596>:
        num_sccs = num_sccs + 1;
        <D.18597>:
        D.18598 = scc->xrefs.size;
        sccs_links.37 = sccs_links;
        D.18600 = D.18598 + sccs_links.37;
        sccs_links = D.18600;
        D.18598 = scc->xrefs.size;
        max_sccs_links.38 = max_sccs_links;
        D.18602 = MAX_EXPR <D.18598, max_sccs_links.38>;
        max_sccs_links = D.18602;
      }
      i = i + 1;
      <D.18088>:
      D.18603 = sccs.size;
      if (D.18603 > i) goto <D.18087>; else goto <D.18089>;
      <D.18089>:
      D.18604 = (long unsigned int) num_sccs;
      D.18605 = D.18604 * 8;
      api_sccs = sgen_alloc_internal_dynamic (D.18605, 21, 1);
      num_xrefs = 0;
      j = 0;
      i = 0;
      goto <D.18093>;
      <D.18092>:
      {
        struct SCC * scc;

        D.18585 = sccs.data;
        D.18586 = sccs.elem_size;
        D.18587 = D.18586 * i;
        D.18588 = (sizetype) D.18587;
        scc = D.18585 + D.18588;
        D.18606 = scc->num_bridge_entries;
        if (D.18606 == 0) goto <D.18607>; else goto <D.18608>;
        <D.18607>:
        // predicted unlikely by continue predictor.
        goto <D.18091>;
        <D.18608>:
        D.18609 = (long unsigned int) j;
        D.18610 = D.18609 * 8;
        D.18611 = api_sccs + D.18610;
        D.18606 = scc->num_bridge_entries;
        D.18612 = (long unsigned int) D.18606;
        D.18613 = D.18612 + 1;
        D.18614 = D.18613 * 8;
        D.18615 = sgen_alloc_internal_dynamic (D.18614, 21, 1);
        *D.18611 = D.18615;
        D.18609 = (long unsigned int) j;
        D.18610 = D.18609 * 8;
        D.18611 = api_sccs + D.18610;
        D.18616 = *D.18611;
        D.18616->is_alive = 0;
        D.18609 = (long unsigned int) j;
        D.18610 = D.18609 * 8;
        D.18611 = api_sccs + D.18610;
        D.18616 = *D.18611;
        D.18606 = scc->num_bridge_entries;
        D.18616->num_objs = D.18606;
        scc->num_bridge_entries = 0;
        j.39 = j;
        j = j.39 + 1;
        scc->api_index = j.39;
        D.18618 = scc->xrefs.size;
        num_xrefs = D.18618 + num_xrefs;
      }
      <D.18091>:
      i = i + 1;
      <D.18093>:
      D.18603 = sccs.size;
      if (D.18603 > i) goto <D.18092>; else goto <D.18094>;
      <D.18094>:
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

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

          D.18619 = (long unsigned int) __i;
          D.18620 = D.18619 * 8;
          __iter = __table + D.18620;
          goto <D.18103>;
          <D.18102>:
          {
            struct SgenHashTableEntry * __entry;

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

              D.18585 = sccs.data;
              D.18624 = entry->scc_index;
              D.18586 = sccs.elem_size;
              D.18625 = D.18624 * D.18586;
              D.18626 = (sizetype) D.18625;
              scc = D.18585 + D.18626;
              D.18627 = scc->api_index;
              D.18628 = (long unsigned int) D.18627;
              D.18629 = D.18628 * 8;
              D.18630 = api_sccs + D.18629;
              D.18631 = *D.18630;
              D.18632 = scc->num_bridge_entries;
              D.18633 = D.18632;
              D.18634 = D.18633 + 1;
              scc->num_bridge_entries = D.18634;
              D.18635 = entry->obj;
              D.18631->objs[D.18633] = D.18635;
            }
            <D.18623>:
          }
          __iter = __next;
          <D.18103>:
          D.18636 = *__iter;
          if (D.18636 != 0B) goto <D.18102>; else goto <D.18104>;
          <D.18104>:
        }
        __i = __i + 1;
        <D.18106>:
        D.18556 = hash_table.size;
        if (D.18556 > __i) goto <D.18105>; else goto <D.18107>;
        <D.18107>:
      }
      D.18637 = (long unsigned int) num_xrefs;
      D.18638 = D.18637 * 8;
      api_xrefs = sgen_alloc_internal_dynamic (D.18638, 21, 1);
      j = 0;
      i = 0;
      goto <D.18117>;
      <D.18116>:
      {
        int k;
        struct SCC * scc;

        D.18585 = sccs.data;
        D.18586 = sccs.elem_size;
        D.18587 = D.18586 * i;
        D.18588 = (sizetype) D.18587;
        scc = D.18585 + D.18588;
        D.18639 = scc->num_bridge_entries;
        if (D.18639 == 0) goto <D.18640>; else goto <D.18641>;
        <D.18640>:
        // predicted unlikely by continue predictor.
        goto <D.18110>;
        <D.18641>:
        k = 0;
        goto <D.18114>;
        <D.18113>:
        {
          struct SCC * src_scc;

          D.18585 = sccs.data;
          D.18642 = scc->xrefs.data;
          D.18643 = (long unsigned int) k;
          D.18644 = D.18643 * 4;
          D.18645 = D.18642 + D.18644;
          D.18646 = *D.18645;
          D.18586 = sccs.elem_size;
          D.18647 = D.18646 * D.18586;
          D.18648 = (sizetype) D.18647;
          src_scc = D.18585 + D.18648;
          D.18649 = src_scc->num_bridge_entries;
          if (D.18649 == 0) goto <D.18650>; else goto <D.18651>;
          <D.18650>:
          // predicted unlikely by continue predictor.
          goto <D.18112>;
          <D.18651>:
          D.18609 = (long unsigned int) j;
          D.18610 = D.18609 * 8;
          D.18652 = api_xrefs + D.18610;
          D.18653 = src_scc->api_index;
          D.18652->src_scc_index = D.18653;
          D.18609 = (long unsigned int) j;
          D.18610 = D.18609 * 8;
          D.18652 = api_xrefs + D.18610;
          D.18654 = scc->api_index;
          D.18652->dst_scc_index = D.18654;
          j = j + 1;
        }
        <D.18112>:
        k = k + 1;
        <D.18114>:
        D.18655 = scc->xrefs.size;
        if (D.18655 > k) goto <D.18113>; else goto <D.18115>;
        <D.18115>:
      }
      <D.18110>:
      i = i + 1;
      <D.18117>:
      D.18603 = sccs.size;
      if (D.18603 > i) goto <D.18116>; else goto <D.18118>;
      <D.18118>:
      btv = mono_100ns_ticks ();
      D.18564 = btv - atv;
      D.18565 = D.18564 / 10;
      D.18566 = (int) D.18565;
      D.18567 = (long unsigned int) D.18566;
      step_5 = D.18567;
      j = 0;
      max_xrefs = 0;
      max_entries = max_xrefs;
      i = 0;
      goto <D.18121>;
      <D.18120>:
      {
        struct SCC * scc;

        D.18585 = sccs.data;
        D.18586 = sccs.elem_size;
        D.18587 = D.18586 * i;
        D.18588 = (sizetype) D.18587;
        scc = D.18585 + D.18588;
        D.18656 = scc->num_bridge_entries;
        if (D.18656 != 0) goto <D.18657>; else goto <D.18658>;
        <D.18657>:
        j = j + 1;
        <D.18658>:
        D.18656 = scc->num_bridge_entries;
        if (D.18656 > max_entries) goto <D.18659>; else goto <D.18660>;
        <D.18659>:
        max_entries = scc->num_bridge_entries;
        <D.18660>:
        D.18661 = scc->xrefs.size;
        if (D.18661 > max_xrefs) goto <D.18662>; else goto <D.18663>;
        <D.18662>:
        max_xrefs = scc->xrefs.size;
        <D.18663>:
        D.18664 = &scc->xrefs;
        dyn_array_uninit (D.18664);
      }
      i = i + 1;
      <D.18121>:
      D.18603 = sccs.size;
      if (D.18603 > i) goto <D.18120>; else goto <D.18122>;
      <D.18122>:
      dyn_array_uninit (&sccs);
      D.18537 = hash_table.num_entries;
      D.18538 = (long unsigned int) D.18537;
      D.18539 = D.18538 * 8;
      sgen_free_internal_dynamic (all_entries, D.18539, 21);
      free_data ();
      num_registered_bridges = registered_bridges.size;
      registered_bridges.size = 0;
      atv = mono_100ns_ticks ();
      D.18581 = atv - btv;
      D.18582 = D.18581 / 10;
      D.18583 = (int) D.18582;
      D.18584 = (long unsigned int) D.18583;
      step_6 = D.18584;
      D.18665 = bridge_callbacks.cross_references;
      D.18665 (num_sccs, api_sccs, num_xrefs, api_xrefs);
      btv = mono_100ns_ticks ();
      D.18564 = btv - atv;
      D.18565 = D.18564 / 10;
      D.18566 = (int) D.18565;
      D.18567 = (long unsigned int) D.18566;
      step_7 = D.18567;
      i = 0;
      goto <D.18128>;
      <D.18127>:
      {
        unsigned char alive;

        try
          {
            D.18568 = (long unsigned int) i;
            D.18569 = D.18568 * 8;
            D.18666 = api_sccs + D.18569;
            D.18667 = *D.18666;
            D.18668 = D.18667->is_alive;
            D.18669 = D.18668 != 0;
            alive.40 = (unsigned char) D.18669;
            alive = alive.40;
            j = 0;
            goto <D.18125>;
            <D.18124>:
            D.18568 = (long unsigned int) i;
            D.18569 = D.18568 * 8;
            D.18666 = api_sccs + D.18569;
            D.18667 = *D.18666;
            D.18671 = D.18667->objs[j];
            sgen_hash_table_replace (&alive_hash, D.18671, &alive, 0B);
            D.18568 = (long unsigned int) i;
            D.18569 = D.18568 * 8;
            D.18666 = api_sccs + D.18569;
            D.18667 = *D.18666;
            D.18668 = D.18667->is_alive;
            if (D.18668 == 0) goto <D.18672>; else goto <D.18673>;
            <D.18672>:
            D.18568 = (long unsigned int) i;
            D.18569 = D.18568 * 8;
            D.18666 = api_sccs + D.18569;
            D.18667 = *D.18666;
            D.18671 = D.18667->objs[j];
            sgen_mark_bridge_object (D.18671);
            <D.18673>:
            j = j + 1;
            <D.18125>:
            D.18568 = (long unsigned int) i;
            D.18569 = D.18568 * 8;
            D.18666 = api_sccs + D.18569;
            D.18667 = *D.18666;
            D.18674 = D.18667->num_objs;
            if (D.18674 > j) goto <D.18124>; else goto <D.18126>;
            <D.18126>:
          }
        finally
          {
            alive = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18128>:
      if (i < num_sccs) goto <D.18127>; else goto <D.18129>;
      <D.18129>:
      sgen_null_links_with_predicate (0, is_bridge_object_alive, &alive_hash);
      if (generation == 1) goto <D.18675>; else goto <D.18676>;
      <D.18675>:
      sgen_null_links_with_predicate (1, is_bridge_object_alive, &alive_hash);
      <D.18676>:
      sgen_hash_table_clean (&alive_hash);
      i = 0;
      goto <D.18131>;
      <D.18130>:
      D.18568 = (long unsigned int) i;
      D.18569 = D.18568 * 8;
      D.18666 = api_sccs + D.18569;
      D.18667 = *D.18666;
      D.18568 = (long unsigned int) i;
      D.18569 = D.18568 * 8;
      D.18666 = api_sccs + D.18569;
      D.18667 = *D.18666;
      D.18674 = D.18667->num_objs;
      D.18677 = (long unsigned int) D.18674;
      D.18678 = D.18677 + 1;
      D.18679 = D.18678 * 8;
      sgen_free_internal_dynamic (D.18667, D.18679, 21);
      i = i + 1;
      <D.18131>:
      if (i < num_sccs) goto <D.18130>; else goto <D.18132>;
      <D.18132>:
      D.18604 = (long unsigned int) num_sccs;
      D.18605 = D.18604 * 8;
      sgen_free_internal_dynamic (api_sccs, D.18605, 21);
      D.18637 = (long unsigned int) num_xrefs;
      D.18638 = D.18637 * 8;
      sgen_free_internal_dynamic (api_xrefs, D.18638, 21);
      atv = mono_100ns_ticks ();
      D.18581 = atv - btv;
      D.18582 = D.18581 / 10;
      D.18583 = (int) D.18582;
      D.18584 = (long unsigned int) D.18583;
      step_8 = D.18584;
      D.18603 = sccs.size;
      step_1.41 = step_1;
      D.18681 = (float) step_1.41;
      D.18682 = D.18681 / 1.0e+3;
      D.18683 = (double) D.18682;
      step_2.42 = step_2;
      D.18685 = (float) step_2.42;
      D.18686 = D.18685 / 1.0e+3;
      D.18687 = (double) D.18686;
      step_3.43 = step_3;
      D.18689 = (float) step_3.43;
      D.18690 = D.18689 / 1.0e+3;
      D.18691 = (double) D.18690;
      step_4.44 = step_4;
      D.18693 = (float) step_4.44;
      D.18694 = D.18693 / 1.0e+3;
      D.18695 = (double) D.18694;
      step_5.45 = step_5;
      D.18697 = (float) step_5.45;
      D.18698 = D.18697 / 1.0e+3;
      D.18699 = (double) D.18698;
      step_6.46 = step_6;
      D.18701 = (float) step_6.46;
      D.18702 = D.18701 / 1.0e+3;
      D.18703 = (double) D.18702;
      step_7.47 = step_7;
      D.18705 = (float) step_7.47;
      D.18706 = D.18705 / 1.0e+3;
      D.18707 = (double) D.18706;
      step_8.48 = step_8;
      D.18709 = (float) step_8.48;
      D.18710 = D.18709 / 1.0e+3;
      D.18711 = (double) D.18710;
      fist_pass_links.32 = fist_pass_links;
      second_pass_links.36 = second_pass_links;
      sccs_links.37 = sccs_links;
      max_sccs_links.38 = max_sccs_links;
      dsf1_passes.49 = dsf1_passes;
      dsf2_passes.50 = 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.18603, D.18683, D.18687, D.18691, D.18695, D.18699, D.18703, D.18707, D.18711, fist_pass_links.32, second_pass_links.36, sccs_links.37, max_sccs_links.38, dsf1_passes.49, dsf2_passes.50);
      step_1 = 0;
      bridge_processing_in_progress = 0;
    }
  finally
    {
      alive_hash = {CLOBBER};
    }
}


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

  table = data;
  value = sgen_hash_table_lookup (table, obj);
  if (value == 0B) goto <D.18717>; else goto <D.18718>;
  <D.18717>:
  D.18719 = 1;
  return D.18719;
  <D.18718>:
  D.18720 = *value;
  D.18719 = (mono_bool) D.18720;
  return D.18719;
}


compare_hash_entries (const void * ep1, const void * ep2)
{
  int D.18722;
  int D.18723;
  int D.18724;
  struct HashEntry * e1;
  struct HashEntry * e2;

  e1 = MEM[(struct HashEntry * *)ep1];
  e2 = MEM[(struct HashEntry * *)ep2];
  D.18723 = e2->finishing_time;
  D.18724 = e1->finishing_time;
  D.18722 = D.18723 - D.18724;
  return D.18722;
}


dfs2 (struct HashEntry * entry)
{
  int D.18726;
  _Bool D.18727;
  long int D.18728;
  long int D.18729;
  int dsf2_passes.51;
  int D.18733;
  int D.18734;
  struct SCC * current_scc.52;
  int D.18738;
  char * D.18741;
  int D.18742;
  int D.18743;
  sizetype D.18744;
  char * D.18745;
  char * D.18746;
  long unsigned int D.18747;
  long unsigned int D.18748;
  void * * D.18749;
  void * D.18750;
  int D.18751;
  int i;

  D.18726 = dfs_stack.size;
  D.18727 = D.18726 != 0;
  D.18728 = (long int) D.18727;
  D.18729 = __builtin_expect (D.18728, 0);
  if (D.18729 != 0) goto <D.18730>; else goto <D.18731>;
  <D.18730>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 501, "dfs_stack.size == 0");
  <D.18731>:
  dyn_array_ptr_add (&dfs_stack, entry);
  <D.18001>:
  entry = dyn_array_ptr_pop (&dfs_stack);
  dsf2_passes.51 = dsf2_passes;
  D.18733 = dsf2_passes.51 + 1;
  dsf2_passes = D.18733;
  D.18734 = entry->scc_index;
  if (D.18734 >= 0) goto <D.18735>; else goto <D.18736>;
  <D.18735>:
  D.18734 = entry->scc_index;
  current_scc.52 = current_scc;
  D.18738 = current_scc.52->index;
  if (D.18734 != D.18738) goto <D.18739>; else goto <D.18740>;
  <D.18739>:
  D.18741 = sccs.data;
  D.18734 = entry->scc_index;
  D.18742 = sccs.elem_size;
  D.18743 = D.18734 * D.18742;
  D.18744 = (sizetype) D.18743;
  D.18745 = D.18741 + D.18744;
  current_scc.52 = current_scc;
  scc_add_xref (D.18745, current_scc.52);
  <D.18740>:
  // predicted unlikely by continue predictor.
  goto <D.17997>;
  <D.18736>:
  current_scc.52 = current_scc;
  scc_add_entry (current_scc.52, entry);
  i = 0;
  goto <D.17999>;
  <D.17998>:
  D.18746 = entry->srcs.data;
  D.18747 = (long unsigned int) i;
  D.18748 = D.18747 * 8;
  D.18749 = D.18746 + D.18748;
  D.18750 = *D.18749;
  dyn_array_ptr_add (&dfs_stack, D.18750);
  i = i + 1;
  <D.17999>:
  D.18751 = entry->srcs.size;
  if (D.18751 > i) goto <D.17998>; else goto <D.18000>;
  <D.18000>:
  <D.17997>:
  D.18726 = dfs_stack.size;
  if (D.18726 > 0) goto <D.18001>; else goto <D.18002>;
  <D.18002>:
}


scc_add_xref (struct SCC * src, struct SCC * dst)
{
  _Bool D.18752;
  long int D.18753;
  long int D.18754;
  int D.18757;
  int D.18758;
  _Bool D.18759;
  long int D.18760;
  long int D.18761;
  struct DynArray * D.18764;
  int D.18765;
  int D.18768;
  struct DynArray * D.18772;
  char * D.18773;
  long unsigned int D.18774;
  long unsigned int D.18775;
  int * D.18776;
  int D.18777;
  _Bool D.18778;
  long int D.18779;
  long int D.18780;
  int D.18783;

  D.18752 = src == dst;
  D.18753 = (long int) D.18752;
  D.18754 = __builtin_expect (D.18753, 0);
  if (D.18754 != 0) goto <D.18755>; else goto <D.18756>;
  <D.18755>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 469, "src != dst");
  <D.18756>:
  D.18757 = src->index;
  D.18758 = dst->index;
  D.18759 = D.18757 == D.18758;
  D.18760 = (long int) D.18759;
  D.18761 = __builtin_expect (D.18760, 0);
  if (D.18761 != 0) goto <D.18762>; else goto <D.18763>;
  <D.18762>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 470, "src->index != dst->index");
  <D.18763>:
  D.18764 = &dst->xrefs;
  D.18757 = src->index;
  D.18765 = dyn_array_int_contains (D.18764, D.18757);
  if (D.18765 != 0) goto <D.18766>; else goto <D.18767>;
  <D.18766>:
  return;
  <D.18767>:
  D.18768 = src->num_bridge_entries;
  if (D.18768 != 0) goto <D.18769>; else goto <D.18770>;
  <D.18769>:
  D.18764 = &dst->xrefs;
  D.18757 = src->index;
  dyn_array_int_merge_one (D.18764, D.18757);
  goto <D.18771>;
  <D.18770>:
  {
    int i;

    D.18764 = &dst->xrefs;
    D.18772 = &src->xrefs;
    dyn_array_int_merge (D.18764, D.18772);
    i = 0;
    goto <D.17985>;
    <D.17984>:
    D.18773 = dst->xrefs.data;
    D.18774 = (long unsigned int) i;
    D.18775 = D.18774 * 4;
    D.18776 = D.18773 + D.18775;
    D.18777 = *D.18776;
    D.18758 = dst->index;
    D.18778 = D.18777 == D.18758;
    D.18779 = (long int) D.18778;
    D.18780 = __builtin_expect (D.18779, 0);
    if (D.18780 != 0) goto <D.18781>; else goto <D.18782>;
    <D.18781>:
    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.18782>:
    i = i + 1;
    <D.17985>:
    D.18783 = dst->xrefs.size;
    if (D.18783 > i) goto <D.17984>; else goto <D.17986>;
    <D.17986>:
  }
  <D.18771>:
}


dyn_array_int_contains (struct DynArray * da, int x)
{
  char * D.18785;
  long unsigned int D.18786;
  long unsigned int D.18787;
  int * D.18788;
  int D.18789;
  gboolean D.18792;
  int D.18793;
  int i;

  i = 0;
  goto <D.17765>;
  <D.17764>:
  D.18785 = da->data;
  D.18786 = (long unsigned int) i;
  D.18787 = D.18786 * 4;
  D.18788 = D.18785 + D.18787;
  D.18789 = *D.18788;
  if (D.18789 == x) goto <D.18790>; else goto <D.18791>;
  <D.18790>:
  D.18792 = 1;
  return D.18792;
  <D.18791>:
  i = i + 1;
  <D.17765>:
  D.18793 = da->size;
  if (D.18793 > i) goto <D.17764>; else goto <D.17766>;
  <D.17766>:
  D.18792 = 0;
  return D.18792;
}


dyn_array_int_merge_one (struct DynArray * array, int value)
{
  char * D.18795;
  long unsigned int D.18796;
  long unsigned int D.18797;
  int * D.18798;
  int D.18799;
  int D.18803;
  int D.18804;
  sizetype D.18807;
  sizetype D.18808;
  sizetype D.18809;
  int * D.18810;
  sizetype D.18811;
  sizetype D.18812;
  sizetype D.18813;
  int * D.18814;
  long unsigned int D.18816;
  long unsigned int D.18817;
  int * D.18818;
  int i;
  int tmp;
  int end;

  end = array->size;
  i = 0;
  goto <D.17788>;
  <D.17787>:
  D.18795 = array->data;
  D.18796 = (long unsigned int) i;
  D.18797 = D.18796 * 4;
  D.18798 = D.18795 + D.18797;
  D.18799 = *D.18798;
  if (D.18799 == value) goto <D.18800>; else goto <D.18801>;
  <D.18800>:
  return;
  <D.18801>:
  D.18795 = array->data;
  D.18796 = (long unsigned int) i;
  D.18797 = D.18796 * 4;
  D.18798 = D.18795 + D.18797;
  D.18799 = *D.18798;
  if (D.18799 > value) goto <D.17786>; else goto <D.18802>;
  <D.18802>:
  i = i + 1;
  <D.17788>:
  if (i < end) goto <D.17787>; else goto <D.17786>;
  <D.17786>:
  D.18803 = array->size;
  D.18804 = D.18803 + 1;
  dyn_array_ensure_capacity (array, D.18804);
  if (i < end) goto <D.18805>; else goto <D.18806>;
  <D.18805>:
  D.18795 = array->data;
  D.18796 = (long unsigned int) i;
  D.18797 = D.18796 * 4;
  D.18798 = D.18795 + D.18797;
  tmp = *D.18798;
  goto <D.17790>;
  <D.17789>:
  D.18795 = array->data;
  D.18796 = (long unsigned int) i;
  D.18797 = D.18796 * 4;
  D.18798 = D.18795 + D.18797;
  *D.18798 = value;
  value = tmp;
  D.18795 = array->data;
  D.18807 = (sizetype) i;
  D.18808 = D.18807 + 1;
  D.18809 = D.18808 * 4;
  D.18810 = D.18795 + D.18809;
  tmp = *D.18810;
  i = i + 1;
  <D.17790>:
  if (i <= end) goto <D.17789>; else goto <D.17791>;
  <D.17791>:
  D.18795 = array->data;
  D.18811 = (sizetype) end;
  D.18812 = D.18811 + 1;
  D.18813 = D.18812 * 4;
  D.18814 = D.18795 + D.18813;
  *D.18814 = tmp;
  goto <D.18815>;
  <D.18806>:
  D.18795 = array->data;
  D.18816 = (long unsigned int) end;
  D.18817 = D.18816 * 4;
  D.18818 = D.18795 + D.18817;
  *D.18818 = value;
  <D.18815>:
  D.18803 = array->size;
  D.18804 = D.18803 + 1;
  array->size = D.18804;
}


dyn_array_int_merge (struct DynArray * dst, struct DynArray * src)
{
  int D.18820;
  int D.18821;
  int D.18822;
  char * D.18827;
  long unsigned int D.18828;
  long unsigned int D.18829;
  int * D.18830;
  char * D.18831;
  long unsigned int D.18832;
  long unsigned int D.18833;
  int * D.18834;
  int D.18843;
  int D.18845;
  int D.18847;
  char * D.18850;
  int D.18851;
  int D.18852;
  long unsigned int D.18853;
  int i;
  int j;

  D.18820 = dst->size;
  D.18821 = src->size;
  D.18822 = D.18820 + D.18821;
  dyn_array_ensure_capacity (&merge_array, D.18822);
  merge_array.size = 0;
  j = 0;
  i = j;
  goto <D.17777>;
  <D.17776>:
  D.18820 = dst->size;
  if (D.18820 > i) goto <D.18825>; else goto <D.18823>;
  <D.18825>:
  D.18821 = src->size;
  if (D.18821 > j) goto <D.18826>; else goto <D.18823>;
  <D.18826>:
  {
    int a;
    int b;

    D.18827 = dst->data;
    D.18828 = (long unsigned int) i;
    D.18829 = D.18828 * 4;
    D.18830 = D.18827 + D.18829;
    a = *D.18830;
    D.18831 = src->data;
    D.18832 = (long unsigned int) j;
    D.18833 = D.18832 * 4;
    D.18834 = D.18831 + D.18833;
    b = *D.18834;
    if (a < b) goto <D.18835>; else goto <D.18836>;
    <D.18835>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    goto <D.18837>;
    <D.18836>:
    if (a == b) goto <D.18838>; else goto <D.18839>;
    <D.18838>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    j = j + 1;
    goto <D.18840>;
    <D.18839>:
    dyn_array_int_add (&merge_array, b);
    j = j + 1;
    <D.18840>:
    <D.18837>:
  }
  goto <D.18824>;
  <D.18823>:
  D.18820 = dst->size;
  if (D.18820 > i) goto <D.18841>; else goto <D.18842>;
  <D.18841>:
  D.18827 = dst->data;
  D.18828 = (long unsigned int) i;
  D.18829 = D.18828 * 4;
  D.18830 = D.18827 + D.18829;
  D.18843 = *D.18830;
  dyn_array_int_add (&merge_array, D.18843);
  i = i + 1;
  goto <D.18844>;
  <D.18842>:
  D.18831 = src->data;
  D.18832 = (long unsigned int) j;
  D.18833 = D.18832 * 4;
  D.18834 = D.18831 + D.18833;
  D.18845 = *D.18834;
  dyn_array_int_add (&merge_array, D.18845);
  j = j + 1;
  <D.18844>:
  <D.18824>:
  <D.17777>:
  D.18820 = dst->size;
  if (D.18820 > i) goto <D.17776>; else goto <D.18846>;
  <D.18846>:
  D.18821 = src->size;
  if (D.18821 > j) goto <D.17776>; else goto <D.17778>;
  <D.17778>:
  D.18847 = merge_array.size;
  D.18820 = dst->size;
  if (D.18847 > D.18820) goto <D.18848>; else goto <D.18849>;
  <D.18848>:
  D.18847 = merge_array.size;
  dyn_array_ensure_capacity (dst, D.18847);
  D.18827 = dst->data;
  D.18850 = merge_array.data;
  D.18847 = merge_array.size;
  D.18851 = merge_array.elem_size;
  D.18852 = D.18847 * D.18851;
  D.18853 = (long unsigned int) D.18852;
  memcpy (D.18827, D.18850, D.18853);
  D.18847 = merge_array.size;
  dst->size = D.18847;
  <D.18849>:
}


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.18854;
  _Bool D.18855;
  long int D.18856;
  long int D.18857;
  int D.18860;
  int D.18861;
  int D.18864;
  int D.18865;

  D.18854 = entry->scc_index;
  D.18855 = D.18854 >= 0;
  D.18856 = (long int) D.18855;
  D.18857 = __builtin_expect (D.18856, 0);
  if (D.18857 != 0) goto <D.18858>; else goto <D.18859>;
  <D.18858>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 487, "entry->scc_index < 0");
  <D.18859>:
  D.18860 = scc->index;
  entry->scc_index = D.18860;
  D.18861 = entry->is_bridge;
  if (D.18861 != 0) goto <D.18862>; else goto <D.18863>;
  <D.18862>:
  D.18864 = scc->num_bridge_entries;
  D.18865 = D.18864 + 1;
  scc->num_bridge_entries = D.18865;
  <D.18863>:
}


dyn_array_uninit (struct DynArray * da)
{
  int D.18866;
  char * D.18869;
  int D.18870;
  int D.18871;
  long unsigned int D.18872;

  D.18866 = da->capacity;
  if (D.18866 <= 0) goto <D.18867>; else goto <D.18868>;
  <D.18867>:
  return;
  <D.18868>:
  D.18869 = da->data;
  D.18870 = da->elem_size;
  D.18866 = da->capacity;
  D.18871 = D.18870 * D.18866;
  D.18872 = (long unsigned int) D.18871;
  sgen_free_internal_dynamic (D.18869, D.18872, 21);
  da->data = 0B;
}


free_data ()
{
  long unsigned int D.18874;
  long unsigned int D.18875;
  int D.18876;
  struct DynArray * D.18879;
  struct SgenHashTableEntry * D.18880;
  unsigned int D.18881;
  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.17853>;
    <D.17852>:
    {
      struct SgenHashTableEntry * * __iter;
      struct SgenHashTableEntry * * __next;

      D.18874 = (long unsigned int) __i;
      D.18875 = D.18874 * 8;
      __iter = __table + D.18875;
      goto <D.17850>;
      <D.17849>:
      {
        struct SgenHashTableEntry * __entry;

        __entry = *__iter;
        __next = &__entry->next;
        obj = __entry->key;
        entry = &__entry->data;
        D.18876 = entry->srcs.size;
        total_srcs = D.18876 + total_srcs;
        D.18876 = entry->srcs.size;
        if (D.18876 > max_srcs) goto <D.18877>; else goto <D.18878>;
        <D.18877>:
        max_srcs = entry->srcs.size;
        <D.18878>:
        D.18879 = &entry->srcs;
        dyn_array_uninit (D.18879);
      }
      __iter = __next;
      <D.17850>:
      D.18880 = *__iter;
      if (D.18880 != 0B) goto <D.17849>; else goto <D.17851>;
      <D.17851>:
    }
    __i = __i + 1;
    <D.17853>:
    D.18881 = hash_table.size;
    if (D.18881 > __i) goto <D.17852>; else goto <D.17854>;
    <D.17854>:
  }
  sgen_hash_table_clean (&hash_table);
  dyn_array_uninit (&merge_array);
}


__attribute__((visibility ("hidden")))
sgen_bridge_describe_pointer (struct MonoObject * obj)
{
  char * D.18882;
  long unsigned int D.18883;
  long unsigned int D.18884;
  void * * D.18885;
  void * D.18886;
  int D.18889;
  int D.18892;
  int D.18893;
  struct HashEntry * entry;
  int i;

  i = 0;
  goto <D.18140>;
  <D.18139>:
  D.18882 = registered_bridges.data;
  D.18883 = (long unsigned int) i;
  D.18884 = D.18883 * 8;
  D.18885 = D.18882 + D.18884;
  D.18886 = *D.18885;
  if (D.18886 == obj) goto <D.18887>; else goto <D.18888>;
  <D.18887>:
  printf ("Pointer is a registered bridge object.\n");
  goto <D.18138>;
  <D.18888>:
  i = i + 1;
  <D.18140>:
  D.18889 = registered_bridges.size;
  if (D.18889 > i) goto <D.18139>; else goto <D.18138>;
  <D.18138>:
  entry = sgen_hash_table_lookup (&hash_table, obj);
  if (entry == 0B) goto <D.18890>; else goto <D.18891>;
  <D.18890>:
  return;
  <D.18891>:
  printf ("Bridge hash table entry %p:\n", entry);
  D.18892 = entry->is_bridge;
  printf ("  is bridge: %d\n", D.18892);
  D.18893 = entry->is_visited;
  printf ("  is visited: %d\n", D.18893);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.18895;

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


__attribute__((visibility ("hidden")))
sgen_register_test_bridge_callbacks (const char * bridge_class_name)
{
  void (*<T302b>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) iftmp.53;
  char D.18898;
  sizetype iftmp.54;
  const char * D.18906;
  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.18898 = *bridge_class_name;
      if (D.18898 == 50) goto <D.18899>; else goto <D.18900>;
      <D.18899>:
      iftmp.53 = bridge_test_cross_reference2;
      goto <D.18901>;
      <D.18900>:
      iftmp.53 = bridge_test_cross_reference;
      <D.18901>:
      callbacks.cross_references = iftmp.53;
      mono_gc_register_bridge_callbacks (&callbacks);
      D.18898 = *bridge_class_name;
      if (D.18898 == 50) goto <D.18903>; else goto <D.18904>;
      <D.18903>:
      iftmp.54 = 1;
      goto <D.18905>;
      <D.18904>:
      iftmp.54 = 0;
      <D.18905>:
      D.18906 = bridge_class_name + iftmp.54;
      bridge_class = D.18906;
    }
  finally
    {
      callbacks = {CLOBBER};
    }
}


bridge_test_cross_reference (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  int D.18907;
  long unsigned int D.18910;
  long unsigned int D.18911;
  struct MonoGCBridgeSCC * * D.18912;
  struct MonoGCBridgeSCC * D.18913;
  int D.18914;
  int iftmp.55;
  struct MonoGCBridgeXRef * D.18919;
  int D.18920;
  _Bool D.18922;
  long int D.18923;
  long int D.18924;
  int iftmp.56;
  int D.18931;
  _Bool D.18933;
  long int D.18934;
  long int D.18935;
  int i;

  i = 0;
  goto <D.18160>;
  <D.18159>:
  {
    int j;

    j = 0;
    goto <D.18157>;
    <D.18156>:
    D.18907 = i & 1;
    if (D.18907 != 0) goto <D.18908>; else goto <D.18909>;
    <D.18908>:
    D.18910 = (long unsigned int) i;
    D.18911 = D.18910 * 8;
    D.18912 = sccs + D.18911;
    D.18913 = *D.18912;
    D.18913->is_alive = 1;
    <D.18909>:
    j = j + 1;
    <D.18157>:
    D.18910 = (long unsigned int) i;
    D.18911 = D.18910 * 8;
    D.18912 = sccs + D.18911;
    D.18913 = *D.18912;
    D.18914 = D.18913->num_objs;
    if (D.18914 > j) goto <D.18156>; else goto <D.18158>;
    <D.18158>:
  }
  i = i + 1;
  <D.18160>:
  if (i < num_sccs) goto <D.18159>; else goto <D.18161>;
  <D.18161>:
  i = 0;
  goto <D.18163>;
  <D.18162>:
  D.18910 = (long unsigned int) i;
  D.18911 = D.18910 * 8;
  D.18919 = xrefs + D.18911;
  D.18920 = D.18919->src_scc_index;
  if (D.18920 < 0) goto <D.18916>; else goto <D.18921>;
  <D.18921>:
  D.18910 = (long unsigned int) i;
  D.18911 = D.18910 * 8;
  D.18919 = xrefs + D.18911;
  D.18920 = D.18919->src_scc_index;
  if (D.18920 >= num_sccs) goto <D.18916>; else goto <D.18917>;
  <D.18916>:
  iftmp.55 = 1;
  goto <D.18918>;
  <D.18917>:
  iftmp.55 = 0;
  <D.18918>:
  D.18922 = iftmp.55 != 0;
  D.18923 = (long int) D.18922;
  D.18924 = __builtin_expect (D.18923, 0);
  if (D.18924 != 0) goto <D.18925>; else goto <D.18926>;
  <D.18925>:
  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.18926>:
  D.18910 = (long unsigned int) i;
  D.18911 = D.18910 * 8;
  D.18919 = xrefs + D.18911;
  D.18931 = D.18919->dst_scc_index;
  if (D.18931 < 0) goto <D.18928>; else goto <D.18932>;
  <D.18932>:
  D.18910 = (long unsigned int) i;
  D.18911 = D.18910 * 8;
  D.18919 = xrefs + D.18911;
  D.18931 = D.18919->dst_scc_index;
  if (D.18931 >= num_sccs) goto <D.18928>; else goto <D.18929>;
  <D.18928>:
  iftmp.56 = 1;
  goto <D.18930>;
  <D.18929>:
  iftmp.56 = 0;
  <D.18930>:
  D.18933 = iftmp.56 != 0;
  D.18934 = (long int) D.18933;
  D.18935 = __builtin_expect (D.18934, 0);
  if (D.18935 != 0) goto <D.18936>; else goto <D.18937>;
  <D.18936>:
  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.18937>:
  i = i + 1;
  <D.18163>:
  if (i < num_xrefs) goto <D.18162>; else goto <D.18164>;
  <D.18164>:
}


bridge_test_cross_reference2 (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  struct MonoClassField * mono_bridge_test_field.57;
  struct MonoGCBridgeSCC * D.18941;
  struct MonoObject * D.18942;
  struct MonoClass * D.18943;
  struct MonoClassField * D.18944;
  _Bool D.18945;
  long int D.18946;
  long int D.18947;
  long unsigned int D.18950;
  long unsigned int D.18951;
  struct MonoGCBridgeSCC * * D.18952;
  struct MonoGCBridgeSCC * D.18953;
  int D.18954;
  int D.18957;
  int D.18960;
  struct MonoObject * D.18963;
  struct MonoGCBridgeXRef * D.18964;
  int D.18965;
  long unsigned int D.18966;
  long unsigned int D.18967;
  struct MonoGCBridgeSCC * * D.18968;
  struct MonoGCBridgeSCC * D.18969;
  int D.18970;
  int D.18973;
  long unsigned int D.18974;
  long unsigned int D.18975;
  struct MonoGCBridgeSCC * * D.18976;
  struct MonoGCBridgeSCC * D.18977;
  int D.18978;
  int i;
  gboolean modified;

  mono_bridge_test_field.57 = mono_bridge_test_field;
  if (mono_bridge_test_field.57 == 0B) goto <D.18939>; else goto <D.18940>;
  <D.18939>:
  D.18941 = *sccs;
  D.18942 = D.18941->objs[0];
  D.18943 = mono_object_get_class (D.18942);
  D.18944 = mono_class_get_field_from_name (D.18943, "__test");
  mono_bridge_test_field = D.18944;
  mono_bridge_test_field.57 = mono_bridge_test_field;
  D.18945 = mono_bridge_test_field.57 == 0B;
  D.18946 = (long int) D.18945;
  D.18947 = __builtin_expect (D.18946, 0);
  if (D.18947 != 0) goto <D.18948>; else goto <D.18949>;
  <D.18948>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 912, "mono_bridge_test_field");
  <D.18949>:
  <D.18940>:
  i = 0;
  goto <D.18204>;
  <D.18203>:
  {
    int j;
    gboolean live;

    live = 0;
    j = 0;
    goto <D.18197>;
    <D.18196>:
    D.18950 = (long unsigned int) i;
    D.18951 = D.18950 * 8;
    D.18952 = sccs + D.18951;
    D.18953 = *D.18952;
    D.18954 = test_scc (D.18953, j);
    if (D.18954 != 0) goto <D.18955>; else goto <D.18956>;
    <D.18955>:
    live = 1;
    goto <D.18195>;
    <D.18956>:
    j = j + 1;
    <D.18197>:
    D.18950 = (long unsigned int) i;
    D.18951 = D.18950 * 8;
    D.18952 = sccs + D.18951;
    D.18953 = *D.18952;
    D.18957 = D.18953->num_objs;
    if (D.18957 > j) goto <D.18196>; else goto <D.18195>;
    <D.18195>:
    if (live == 0) goto <D.18958>; else goto <D.18959>;
    <D.18958>:
    // predicted unlikely by continue predictor.
    goto <D.18198>;
    <D.18959>:
    j = 0;
    goto <D.18201>;
    <D.18200>:
    D.18950 = (long unsigned int) i;
    D.18951 = D.18950 * 8;
    D.18952 = sccs + D.18951;
    D.18953 = *D.18952;
    D.18960 = test_scc (D.18953, j);
    if (D.18960 == 0) goto <D.18961>; else goto <D.18962>;
    <D.18961>:
    {
      int status;

      try
        {
          status = 2;
          D.18950 = (long unsigned int) i;
          D.18951 = D.18950 * 8;
          D.18952 = sccs + D.18951;
          D.18953 = *D.18952;
          D.18963 = D.18953->objs[j];
          mono_bridge_test_field.57 = mono_bridge_test_field;
          mono_field_set_value (D.18963, mono_bridge_test_field.57, &status);
        }
      finally
        {
          status = {CLOBBER};
        }
    }
    <D.18962>:
    j = j + 1;
    <D.18201>:
    D.18950 = (long unsigned int) i;
    D.18951 = D.18950 * 8;
    D.18952 = sccs + D.18951;
    D.18953 = *D.18952;
    D.18957 = D.18953->num_objs;
    if (D.18957 > j) goto <D.18200>; else goto <D.18202>;
    <D.18202>:
  }
  <D.18198>:
  i = i + 1;
  <D.18204>:
  if (i < num_sccs) goto <D.18203>; else goto <D.18205>;
  <D.18205>:
  modified = 1;
  goto <D.18211>;
  <D.18210>:
  modified = 0;
  i = 0;
  goto <D.18208>;
  <D.18207>:
  {
    struct MonoGCBridgeXRef ref;

    try
      {
        D.18950 = (long unsigned int) i;
        D.18951 = D.18950 * 8;
        D.18964 = xrefs + D.18951;
        ref = *D.18964;
        D.18965 = ref.src_scc_index;
        D.18966 = (long unsigned int) D.18965;
        D.18967 = D.18966 * 8;
        D.18968 = sccs + D.18967;
        D.18969 = *D.18968;
        D.18970 = test_scc (D.18969, 0);
        if (D.18970 != 0) goto <D.18971>; else goto <D.18972>;
        <D.18971>:
        D.18973 = ref.dst_scc_index;
        D.18974 = (long unsigned int) D.18973;
        D.18975 = D.18974 * 8;
        D.18976 = sccs + D.18975;
        D.18977 = *D.18976;
        D.18978 = test_scc (D.18977, 0);
        if (D.18978 == 0) goto <D.18979>; else goto <D.18980>;
        <D.18979>:
        modified = 1;
        D.18973 = ref.dst_scc_index;
        D.18974 = (long unsigned int) D.18973;
        D.18975 = D.18974 * 8;
        D.18976 = sccs + D.18975;
        D.18977 = *D.18976;
        mark_scc (D.18977, 3);
        <D.18980>:
        <D.18972>:
      }
    finally
      {
        ref = {CLOBBER};
      }
  }
  i = i + 1;
  <D.18208>:
  if (i < num_xrefs) goto <D.18207>; else goto <D.18209>;
  <D.18209>:
  <D.18211>:
  if (modified != 0) goto <D.18210>; else goto <D.18212>;
  <D.18212>:
  i = 0;
  goto <D.18214>;
  <D.18213>:
  D.18950 = (long unsigned int) i;
  D.18951 = D.18950 * 8;
  D.18952 = sccs + D.18951;
  D.18953 = *D.18952;
  D.18953->is_alive = 1;
  i = i + 1;
  <D.18214>:
  if (i < num_sccs) goto <D.18213>; else goto <D.18215>;
  <D.18215>:
}


test_scc (struct MonoGCBridgeSCC * scc, int i)
{
  struct MonoObject * D.18981;
  struct MonoClassField * mono_bridge_test_field.58;
  gboolean D.18983;
  int status.59;
  _Bool D.18985;
  int status;

  try
    {
      status = 0;
      D.18981 = scc->objs[i];
      mono_bridge_test_field.58 = mono_bridge_test_field;
      mono_field_get_value (D.18981, mono_bridge_test_field.58, &status);
      status.59 = status;
      D.18985 = status.59 > 0;
      D.18983 = (gboolean) D.18985;
      return D.18983;
    }
  finally
    {
      status = {CLOBBER};
    }
}


mark_scc (struct MonoGCBridgeSCC * scc, int value)
{
  int D.18988;
  struct MonoObject * D.18991;
  struct MonoClassField * mono_bridge_test_field.60;
  int D.18993;
  int i;

  i = 0;
  goto <D.18183>;
  <D.18182>:
  D.18988 = test_scc (scc, i);
  if (D.18988 == 0) goto <D.18989>; else goto <D.18990>;
  <D.18989>:
  {
    int status;

    try
      {
        status = value;
        D.18991 = scc->objs[i];
        mono_bridge_test_field.60 = mono_bridge_test_field;
        mono_field_set_value (D.18991, mono_bridge_test_field.60, &status);
      }
    finally
      {
        status = {CLOBBER};
      }
  }
  <D.18990>:
  i = i + 1;
  <D.18183>:
  D.18993 = scc->num_objs;
  if (D.18993 > i) goto <D.18182>; else goto <D.18184>;
  <D.18184>:
}


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

  D.18994 = 1;
  return D.18994;
}


bridge_test_is_bridge_class (struct MonoClass * class)
{
  gboolean D.18996;
  const char * bridge_class.61;
  const char * D.18998;
  int D.18999;
  _Bool D.19000;

  bridge_class.61 = bridge_class;
  D.18998 = class->name;
  D.18999 = strcmp (bridge_class.61, D.18998);
  D.19000 = D.18999 == 0;
  D.18996 = (gboolean) D.19000;
  return D.18996;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.62;
  int iftmp.63;
  int D.19010;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.19003>; else goto <D.19004>;
  <D.19003>:
  if (__ret == 1) goto <D.19006>; else goto <D.19007>;
  <D.19006>:
  iftmp.63 = -1;
  goto <D.19008>;
  <D.19007>:
  iftmp.63 = 1;
  <D.19008>:
  iftmp.62 = iftmp.63;
  goto <D.19009>;
  <D.19004>:
  iftmp.62 = 0;
  <D.19009>:
  __ret = iftmp.62;
  D.19010 = __ret;
  return D.19010;
}