__attribute__((visibility ("hidden")))
mono_branch_optimize_exception_target (struct MonoCompile * cfg, struct MonoBasicBlock * bb, const char * exname)
{
  unsigned int D.22395;
  unsigned int D.22396;
  struct MonoInst * D.22399;
  unsigned int D.22402;
  unsigned int D.22404;
  struct MonoImage * D.22405;
  struct MonoExceptionClause * D.22406;
  long unsigned int D.22407;
  long unsigned int D.22408;
  unsigned int D.22409;
  unsigned int D.22410;
  unsigned int D.22413;
  unsigned int D.22414;
  unsigned int D.22418;
  struct MonoClass * D.22420;
  int D.22422;
  struct MonoBasicBlock * * D.22424;
  unsigned int D.22425;
  long unsigned int D.22426;
  long unsigned int D.22427;
  struct MonoBasicBlock * * D.22428;
  long unsigned int D.22431;
  long unsigned int D.22432;
  struct MonoBasicBlock * D.22434;
  unsigned int D.22435;
  unsigned int D.22436;
  unsigned int D.22441;
  unsigned int D.22442;
  struct MonoMemPool * D.22445;
  int D.22446;
  int D.22447;
  const unsigned char * D.22448;
  void * D.22449;
  struct MonoBasicBlock * * D.22450;
  unsigned int D.22451;
  int D.22454;
  const char * D.22455;
  struct MonoMethod * D.22456;
  struct MonoClass * D.22457;
  const char * D.22458;
  const char * D.22459;
  <unnamed-unsigned:15> D.22460;
  int D.22461;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  struct MonoClass * exclass;
  int i;

  header = cfg->header;
  D.22395 = cfg->opt;
  D.22396 = D.22395 & 1048576;
  if (D.22396 == 0) goto <D.22397>; else goto <D.22398>;
  <D.22397>:
  D.22399 = 0B;
  return D.22399;
  <D.22398>:
  D.22402 = bb->region;
  if (D.22402 == 4294967295) goto <D.22400>; else goto <D.22403>;
  <D.22403>:
  D.22402 = bb->region;
  D.22404 = D.22402 & 240;
  if (D.22404 != 0) goto <D.22400>; else goto <D.22401>;
  <D.22400>:
  D.22399 = 0B;
  return D.22399;
  <D.22401>:
  D.22405 = mono_get_corlib ();
  exclass = mono_class_from_name (D.22405, "System", exname);
  i = 0;
  goto <D.22158>;
  <D.22157>:
  D.22406 = header->clauses;
  D.22407 = (long unsigned int) i;
  D.22408 = D.22407 * 32;
  clause = D.22406 + D.22408;
  D.22409 = clause->try_offset;
  D.22410 = bb->real_offset;
  if (D.22409 <= D.22410) goto <D.22411>; else goto <D.22412>;
  <D.22411>:
  D.22410 = bb->real_offset;
  D.22409 = clause->try_offset;
  D.22413 = clause->try_len;
  D.22414 = D.22409 + D.22413;
  if (D.22410 < D.22414) goto <D.22415>; else goto <D.22416>;
  <D.22415>:
  D.22418 = clause->flags;
  if (D.22418 == 0) goto <D.22419>; else goto <D.22417>;
  <D.22419>:
  D.22420 = clause->data.catch_class;
  if (D.22420 != 0B) goto <D.22421>; else goto <D.22417>;
  <D.22421>:
  D.22420 = clause->data.catch_class;
  D.22422 = mono_class_is_assignable_from (D.22420, exclass);
  if (D.22422 != 0) goto <D.22423>; else goto <D.22417>;
  <D.22423>:
  {
    struct MonoBasicBlock * tbb;

    D.22424 = cfg->cil_offset_to_bb;
    D.22425 = clause->handler_offset;
    D.22426 = (long unsigned int) D.22425;
    D.22427 = D.22426 * 8;
    D.22428 = D.22424 + D.22427;
    tbb = *D.22428;
    if (tbb != 0B) goto <D.22430>; else goto <D.22429>;
    <D.22430>:
    D.22431 = BIT_FIELD_REF <*tbb, 64, 704>;
    D.22432 = D.22431 & 51539607552;
    if (D.22432 == 17179869184) goto <D.22433>; else goto <D.22429>;
    <D.22433>:
    {
      struct MonoBasicBlock * targetbb;
      gboolean unsafe;

      targetbb = tbb;
      unsafe = 0;
      goto <D.22155>;
      <D.22154>:
      D.22434 = tbb->next_bb;
      D.22435 = D.22434->flags;
      D.22436 = D.22435 & 8;
      if (D.22436 != 0) goto <D.22437>; else goto <D.22438>;
      <D.22437>:
      unsafe = 1;
      goto <D.22153>;
      <D.22438>:
      tbb = tbb->next_bb;
      <D.22155>:
      if (unsafe == 0) goto <D.22439>; else goto <D.22153>;
      <D.22439>:
      D.22434 = tbb->next_bb;
      if (D.22434 != 0B) goto <D.22440>; else goto <D.22153>;
      <D.22440>:
      D.22441 = tbb->region;
      D.22434 = tbb->next_bb;
      D.22442 = D.22434->region;
      if (D.22441 == D.22442) goto <D.22154>; else goto <D.22153>;
      <D.22153>:
      if (unsafe == 0) goto <D.22443>; else goto <D.22444>;
      <D.22443>:
      {
        struct MonoInst * jump;

        D.22445 = cfg->mempool;
        jump = mono_mempool_alloc0 (D.22445, 80);
        jump->opcode = 442;
        jump->dreg = -1;
        jump->sreg3 = -1;
        D.22446 = jump->sreg3;
        jump->sreg2 = D.22446;
        D.22447 = jump->sreg2;
        jump->sreg1 = D.22447;
        D.22448 = cfg->ip;
        jump->cil_code = D.22448;
        D.22445 = cfg->mempool;
        D.22449 = mono_mempool_alloc0 (D.22445, 80);
        jump->data.op[1].src = D.22449;
        D.22450 = jump->data.op[1].many_blocks;
        *D.22450 = targetbb;
        D.22451 = cfg->verbose_level;
        if (D.22451 > 2) goto <D.22452>; else goto <D.22453>;
        <D.22452>:
        D.22454 = targetbb->block_num;
        D.22420 = clause->data.catch_class;
        D.22455 = D.22420->name;
        D.22456 = cfg->method;
        D.22457 = D.22456->klass;
        D.22458 = D.22457->name;
        D.22456 = cfg->method;
        D.22459 = D.22456->name;
        monoeg_g_print ("found exception to optimize - returning branch to BB%d (%s) (instead of throw) for method %s:%s\n", D.22454, D.22455, D.22458, D.22459);
        <D.22453>:
        D.22399 = jump;
        return D.22399;
      }
      <D.22444>:
      D.22399 = 0B;
      return D.22399;
    }
    <D.22429>:
    D.22399 = 0B;
    return D.22399;
  }
  <D.22417>:
  D.22399 = 0B;
  return D.22399;
  <D.22416>:
  <D.22412>:
  i = i + 1;
  <D.22158>:
  D.22460 = header->num_clauses;
  D.22461 = (int) D.22460;
  if (D.22461 > i) goto <D.22157>; else goto <D.22159>;
  <D.22159>:
  D.22399 = 0B;
  return D.22399;
}


mono_replace_ins (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * * prev, struct MonoBasicBlock * first_bb, struct MonoBasicBlock * last_bb)
{
  short unsigned int D.22465;
  struct MonoInst * D.22468;
  struct MonoBasicBlock * * D.22471;
  struct MonoBasicBlock * D.22472;
  short int D.22473;
  struct MonoInst * D.22474;
  struct MonoInst * D.22477;
  struct MonoInst * D.22479;
  <unnamed-unsigned:1> D.22483;
  <unnamed-unsigned:1> D.22484;
  <unnamed-unsigned:1> D.22485;
  unsigned int D.22487;
  struct MonoInst * D.22488;
  <unnamed-unsigned:1> D.22496;
  <unnamed-unsigned:1> D.22497;
  struct MonoInst * D.22500;
  struct MonoBasicBlock * * D.22501;
  long unsigned int D.22502;
  long unsigned int D.22503;
  struct MonoBasicBlock * * D.22504;
  struct MonoBasicBlock * D.22505;
  short int D.22506;
  int D.22507;
  struct MonoInst * D.22511;
  struct MonoBasicBlock * * D.22512;
  struct MonoBasicBlock * D.22513;
  struct MonoBasicBlock * * D.22514;
  int D.22515;
  struct MonoBasicBlock * D.22516;
  struct MonoBasicBlock * D.22517;
  struct MonoInst * next;

  next = ins->next;
  if (next != 0B) goto <D.22463>; else goto <D.22464>;
  <D.22463>:
  D.22465 = next->opcode;
  if (D.22465 == 316) goto <D.22466>; else goto <D.22467>;
  <D.22466>:
  D.22468 = next->next;
  ins->next = D.22468;
  next = next->next;
  <D.22467>:
  <D.22464>:
  if (first_bb == last_bb) goto <D.22469>; else goto <D.22470>;
  <D.22469>:
  goto <D.22180>;
  <D.22179>:
  D.22471 = first_bb->out_bb;
  D.22472 = *D.22471;
  mono_unlink_bblock (cfg, first_bb, D.22472);
  <D.22180>:
  D.22473 = first_bb->out_count;
  if (D.22473 != 0) goto <D.22179>; else goto <D.22181>;
  <D.22181>:
  D.22474 = *prev;
  if (D.22474 != 0B) goto <D.22475>; else goto <D.22476>;
  <D.22475>:
  D.22474 = *prev;
  D.22477 = first_bb->code;
  D.22474->next = D.22477;
  D.22477 = first_bb->code;
  D.22474 = *prev;
  D.22477->prev = D.22474;
  goto <D.22478>;
  <D.22476>:
  D.22477 = first_bb->code;
  bb->code = D.22477;
  <D.22478>:
  D.22479 = last_bb->last_ins;
  D.22479->next = next;
  if (next != 0B) goto <D.22480>; else goto <D.22481>;
  <D.22480>:
  D.22479 = last_bb->last_ins;
  next->prev = D.22479;
  goto <D.22482>;
  <D.22481>:
  D.22479 = last_bb->last_ins;
  bb->last_ins = D.22479;
  <D.22482>:
  D.22479 = last_bb->last_ins;
  *prev = D.22479;
  D.22483 = bb->has_array_access;
  D.22484 = first_bb->has_array_access;
  D.22485 = D.22483 | D.22484;
  bb->has_array_access = D.22485;
  goto <D.22486>;
  <D.22470>:
  {
    int i;
    int count;
    struct MonoBasicBlock * * tmp_bblocks;
    struct MonoBasicBlock * tmp;
    struct MonoInst * last;

    tmp = first_bb;
    goto <D.22188>;
    <D.22187>:
    D.22487 = bb->region;
    tmp->region = D.22487;
    tmp = tmp->next_bb;
    <D.22188>:
    if (tmp != 0B) goto <D.22187>; else goto <D.22189>;
    <D.22189>:
    D.22488 = ins->next;
    if (D.22488 != 0B) goto <D.22489>; else goto <D.22490>;
    <D.22489>:
    D.22488 = ins->next;
    D.22488->prev = 0B;
    <D.22490>:
    ins->next = 0B;
    bb->last_ins = ins;
    D.22479 = last_bb->last_ins;
    if (D.22479 != 0B) goto <D.22491>; else goto <D.22492>;
    <D.22491>:
    D.22479 = last_bb->last_ins;
    D.22479->next = next;
    if (next != 0B) goto <D.22493>; else goto <D.22494>;
    <D.22493>:
    D.22479 = last_bb->last_ins;
    next->prev = D.22479;
    <D.22494>:
    goto <D.22495>;
    <D.22492>:
    last_bb->code = next;
    <D.22495>:
    D.22496 = last_bb->has_array_access;
    D.22483 = bb->has_array_access;
    D.22497 = D.22496 | D.22483;
    last_bb->has_array_access = D.22497;
    if (next != 0B) goto <D.22498>; else goto <D.22499>;
    <D.22498>:
    last = next;
    goto <D.22191>;
    <D.22190>:
    last = last->next;
    <D.22191>:
    D.22500 = last->next;
    if (D.22500 != 0B) goto <D.22190>; else goto <D.22192>;
    <D.22192>:
    last_bb->last_ins = last;
    <D.22499>:
    i = 0;
    goto <D.22194>;
    <D.22193>:
    D.22501 = bb->out_bb;
    D.22502 = (long unsigned int) i;
    D.22503 = D.22502 * 8;
    D.22504 = D.22501 + D.22503;
    D.22505 = *D.22504;
    mono_link_bblock (cfg, last_bb, D.22505);
    i = i + 1;
    <D.22194>:
    D.22506 = bb->out_count;
    D.22507 = (int) D.22506;
    if (D.22507 > i) goto <D.22193>; else goto <D.22195>;
    <D.22195>:
    D.22474 = *prev;
    if (D.22474 != 0B) goto <D.22508>; else goto <D.22509>;
    <D.22508>:
    D.22474 = *prev;
    D.22477 = first_bb->code;
    D.22474->next = D.22477;
    D.22477 = first_bb->code;
    D.22474 = *prev;
    D.22477->prev = D.22474;
    goto <D.22510>;
    <D.22509>:
    D.22477 = first_bb->code;
    bb->code = D.22477;
    <D.22510>:
    D.22511 = first_bb->last_ins;
    bb->last_ins = D.22511;
    D.22483 = bb->has_array_access;
    D.22484 = first_bb->has_array_access;
    D.22485 = D.22483 | D.22484;
    bb->has_array_access = D.22485;
    tmp_bblocks = bb->out_bb;
    D.22506 = bb->out_count;
    count = (int) D.22506;
    i = 0;
    goto <D.22197>;
    <D.22196>:
    D.22502 = (long unsigned int) i;
    D.22503 = D.22502 * 8;
    D.22512 = tmp_bblocks + D.22503;
    D.22513 = *D.22512;
    mono_unlink_bblock (cfg, bb, D.22513);
    i = i + 1;
    <D.22197>:
    if (i < count) goto <D.22196>; else goto <D.22198>;
    <D.22198>:
    i = 0;
    goto <D.22201>;
    <D.22200>:
    {
      struct MonoBasicBlock * out_bb;

      D.22471 = first_bb->out_bb;
      D.22502 = (long unsigned int) i;
      D.22503 = D.22502 * 8;
      D.22514 = D.22471 + D.22503;
      out_bb = *D.22514;
      mono_link_bblock (cfg, bb, out_bb);
    }
    i = i + 1;
    <D.22201>:
    D.22473 = first_bb->out_count;
    D.22515 = (int) D.22473;
    if (D.22515 > i) goto <D.22200>; else goto <D.22202>;
    <D.22202>:
    i = 0;
    goto <D.22205>;
    <D.22204>:
    {
      struct MonoBasicBlock * out_bb;

      D.22501 = bb->out_bb;
      D.22502 = (long unsigned int) i;
      D.22503 = D.22502 * 8;
      D.22504 = D.22501 + D.22503;
      out_bb = *D.22504;
      mono_unlink_bblock (cfg, first_bb, out_bb);
    }
    i = i + 1;
    <D.22205>:
    D.22506 = bb->out_count;
    D.22507 = (int) D.22506;
    if (D.22507 > i) goto <D.22204>; else goto <D.22206>;
    <D.22206>:
    D.22516 = bb->next_bb;
    last_bb->next_bb = D.22516;
    D.22517 = first_bb->next_bb;
    bb->next_bb = D.22517;
    *prev = 0B;
  }
  <D.22486>:
}


__attribute__((visibility ("hidden")))
mono_if_conversion (struct MonoCompile * cfg)
{

}


__attribute__((visibility ("hidden")))
mono_nullify_basic_block (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.22518;

  bb->in_count = 0;
  bb->out_count = 0;
  bb->in_bb = 0B;
  bb->out_bb = 0B;
  bb->next_bb = 0B;
  bb->last_ins = 0B;
  D.22518 = bb->last_ins;
  bb->code = D.22518;
  bb->cil_code = 0B;
}


__attribute__((visibility ("hidden")))
mono_merge_basic_blocks (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * bbn)
{
  <unnamed-unsigned:1> D.22519;
  <unnamed-unsigned:1> D.22520;
  <unnamed-unsigned:1> D.22521;
  <unnamed-unsigned:1> D.22522;
  <unnamed-unsigned:1> D.22523;
  <unnamed-unsigned:1> D.22524;
  struct MonoBasicBlock * * D.22525;
  long unsigned int D.22526;
  long unsigned int D.22527;
  struct MonoBasicBlock * * D.22528;
  struct MonoBasicBlock * D.22529;
  short int D.22530;
  int D.22531;
  struct MonoBasicBlock * D.22532;
  long unsigned int D.22533;
  long unsigned int D.22534;
  short unsigned int D.22537;
  struct MonoBasicBlock * D.22540;
  _Bool D.22541;
  long int D.22542;
  long int D.22543;
  int D.22546;
  int D.22547;
  long unsigned int D.22548;
  struct MonoInst * D.22556;
  struct MonoInst * D.22559;
  struct MonoJumpInfoBBTable * iftmp.0;
  struct MonoJumpInfoBBTable * iftmp.1;
  struct MonoJumpInfoBBTable * iftmp.2;
  struct MonoJumpInfoBBTable * iftmp.3;
  struct MonoBasicBlock * * D.22578;
  long unsigned int D.22579;
  long unsigned int D.22580;
  struct MonoBasicBlock * * D.22581;
  struct MonoBasicBlock * D.22582;
  _Bool D.22585;
  long int D.22586;
  long int D.22587;
  int D.22590;
  struct MonoInst * D.22594;
  short unsigned int D.22596;
  short unsigned int D.22597;
  short unsigned int D.22599;
  short unsigned int D.22601;
  struct MonoBasicBlock * * D.22602;
  struct MonoBasicBlock * * D.22603;
  struct MonoBasicBlock * D.22604;
  _Bool D.22605;
  long int D.22606;
  long int D.22607;
  int D.22619;
  int D.22620;
  <unnamed-unsigned:1> D.22621;
  <unnamed-unsigned:1> D.22622;
  <unnamed-unsigned:1> D.22623;
  <unnamed-unsigned:1> D.22624;
  <unnamed-unsigned:1> D.22625;
  <unnamed-unsigned:1> D.22626;
  struct MonoInst * D.22629;
  struct MonoInst * D.22632;
  struct MonoBasicBlock * D.22635;
  struct MonoBasicBlock * D.22638;
  struct MonoBasicBlock * D.22640;
  short int D.22645;
  struct MonoBasicBlock * * D.22648;
  struct MonoBasicBlock * D.22649;
  struct MonoMemPool * D.22664;
  const unsigned char * D.22665;
  struct MonoInst * inst;
  struct MonoBasicBlock * prev_bb;
  int i;

  D.22519 = bb->has_array_access;
  D.22520 = bbn->has_array_access;
  D.22521 = D.22519 | D.22520;
  bb->has_array_access = D.22521;
  D.22522 = bb->extended;
  D.22523 = bbn->extended;
  D.22524 = D.22522 | D.22523;
  bb->extended = D.22524;
  mono_unlink_bblock (cfg, bb, bbn);
  i = 0;
  goto <D.22289>;
  <D.22288>:
  D.22525 = bbn->out_bb;
  D.22526 = (long unsigned int) i;
  D.22527 = D.22526 * 8;
  D.22528 = D.22525 + D.22527;
  D.22529 = *D.22528;
  mono_link_bblock (cfg, bb, D.22529);
  i = i + 1;
  <D.22289>:
  D.22530 = bbn->out_count;
  D.22531 = (int) D.22530;
  if (D.22531 > i) goto <D.22288>; else goto <D.22290>;
  <D.22290>:
  goto <D.22292>;
  <D.22291>:
  D.22525 = bbn->out_bb;
  D.22532 = *D.22525;
  mono_unlink_bblock (cfg, bbn, D.22532);
  <D.22292>:
  D.22530 = bbn->out_count;
  if (D.22530 != 0) goto <D.22291>; else goto <D.22293>;
  <D.22293>:
  D.22533 = BIT_FIELD_REF <*bb, 64, 1472>;
  D.22534 = D.22533 & 4398046511104;
  if (D.22534 != 0) goto <D.22535>; else goto <D.22536>;
  <D.22535>:
  inst = bb->code;
  goto <D.22295>;
  <D.22294>:
  D.22537 = inst->opcode;
  if (D.22537 == 735) goto <D.22538>; else goto <D.22539>;
  <D.22538>:
  D.22540 = inst->data.op[0].target_block;
  D.22541 = D.22540 != bbn;
  D.22542 = (long int) D.22541;
  D.22543 = __builtin_expect (D.22542, 0);
  if (D.22543 != 0) goto <D.22544>; else goto <D.22545>;
  <D.22544>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 984, "inst->inst_target_bb == bbn");
  <D.22545>:
  inst->opcode = 316;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.22546 = inst->sreg3;
  inst->sreg2 = D.22546;
  D.22547 = inst->sreg2;
  inst->sreg1 = D.22547;
  <D.22539>:
  inst = inst->next;
  <D.22295>:
  if (inst != 0B) goto <D.22294>; else goto <D.22296>;
  <D.22296>:
  <D.22536>:
  D.22533 = BIT_FIELD_REF <*bb, 64, 1472>;
  D.22548 = D.22533 & 8796093022208;
  if (D.22548 != 0) goto <D.22549>; else goto <D.22550>;
  <D.22549>:
  inst = bb->code;
  goto <D.22303>;
  <D.22302>:
  D.22537 = inst->opcode;
  if (D.22537 == 731) goto <D.22551>; else goto <D.22554>;
  <D.22554>:
  D.22537 = inst->opcode;
  if (D.22537 == 732) goto <D.22555>; else goto <D.22552>;
  <D.22555>:
  D.22556 = inst->data.op[1].src;
  if (D.22556 == 8B) goto <D.22551>; else goto <D.22552>;
  <D.22552>:
  D.22537 = inst->opcode;
  if (D.22537 == 370) goto <D.22551>; else goto <D.22557>;
  <D.22557>:
  D.22537 = inst->opcode;
  if (D.22537 == 734) goto <D.22558>; else goto <D.22553>;
  <D.22558>:
  D.22556 = inst->data.op[1].src;
  D.22559 = D.22556->data.op[1].src;
  if (D.22559 == 8B) goto <D.22551>; else goto <D.22553>;
  <D.22551>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.22537 = inst->opcode;
    if (D.22537 == 731) goto <D.22561>; else goto <D.22562>;
    <D.22561>:
    iftmp.0 = inst->data.op[0].p;
    goto <D.22563>;
    <D.22562>:
    D.22537 = inst->opcode;
    if (D.22537 == 732) goto <D.22567>; else goto <D.22565>;
    <D.22567>:
    D.22556 = inst->data.op[1].src;
    if (D.22556 == 8B) goto <D.22568>; else goto <D.22565>;
    <D.22568>:
    iftmp.1 = inst->data.op[0].p;
    goto <D.22566>;
    <D.22565>:
    D.22537 = inst->opcode;
    if (D.22537 == 370) goto <D.22570>; else goto <D.22571>;
    <D.22570>:
    iftmp.2 = inst->data.op[0].p;
    goto <D.22572>;
    <D.22571>:
    D.22537 = inst->opcode;
    if (D.22537 == 734) goto <D.22576>; else goto <D.22574>;
    <D.22576>:
    D.22556 = inst->data.op[1].src;
    D.22559 = D.22556->data.op[1].src;
    if (D.22559 == 8B) goto <D.22577>; else goto <D.22574>;
    <D.22577>:
    D.22556 = inst->data.op[1].src;
    iftmp.3 = D.22556->data.op[0].p;
    goto <D.22575>;
    <D.22574>:
    iftmp.3 = 0B;
    <D.22575>:
    iftmp.2 = iftmp.3;
    <D.22572>:
    iftmp.1 = iftmp.2;
    <D.22566>:
    iftmp.0 = iftmp.1;
    <D.22563>:
    table = iftmp.0;
    i = 0;
    goto <D.22300>;
    <D.22299>:
    D.22578 = table->table;
    D.22579 = (long unsigned int) i;
    D.22580 = D.22579 * 8;
    D.22581 = D.22578 + D.22580;
    D.22582 = *D.22581;
    if (D.22582 != 0B) goto <D.22583>; else goto <D.22584>;
    <D.22583>:
    D.22578 = table->table;
    D.22579 = (long unsigned int) i;
    D.22580 = D.22579 * 8;
    D.22581 = D.22578 + D.22580;
    D.22582 = *D.22581;
    D.22585 = D.22582 != bbn;
    D.22586 = (long int) D.22585;
    D.22587 = __builtin_expect (D.22586, 0);
    if (D.22587 != 0) goto <D.22588>; else goto <D.22589>;
    <D.22588>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 997, "table->table [i] == bbn");
    <D.22589>:
    <D.22584>:
    D.22578 = table->table;
    D.22579 = (long unsigned int) i;
    D.22580 = D.22579 * 8;
    D.22581 = D.22578 + D.22580;
    *D.22581 = 0B;
    i = i + 1;
    <D.22300>:
    D.22590 = table->table_size;
    if (D.22590 > i) goto <D.22299>; else goto <D.22301>;
    <D.22301>:
  }
  <D.22553>:
  inst = inst->next;
  <D.22303>:
  if (inst != 0B) goto <D.22302>; else goto <D.22304>;
  <D.22304>:
  <D.22550>:
  D.22594 = bb->last_ins;
  if (D.22594 != 0B) goto <D.22595>; else goto <D.22591>;
  <D.22595>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22597 = D.22596 + 64985;
  if (D.22597 <= 9) goto <D.22592>; else goto <D.22598>;
  <D.22598>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22599 = D.22596 + 64878;
  if (D.22599 <= 9) goto <D.22592>; else goto <D.22600>;
  <D.22600>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22601 = D.22596 + 64888;
  if (D.22601 <= 9) goto <D.22592>; else goto <D.22591>;
  <D.22592>:
  D.22594 = bb->last_ins;
  D.22602 = D.22594->data.op[1].many_blocks;
  D.22603 = D.22602 + 8;
  D.22604 = *D.22603;
  D.22605 = D.22604 != bbn;
  D.22606 = (long int) D.22605;
  D.22607 = __builtin_expect (D.22606, 0);
  if (D.22607 != 0) goto <D.22608>; else goto <D.22609>;
  <D.22608>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1005, "bb->last_ins->inst_false_bb == bbn");
  <D.22609>:
  D.22594 = bb->last_ins;
  D.22602 = D.22594->data.op[1].many_blocks;
  D.22603 = D.22602 + 8;
  *D.22603 = 0B;
  bb->extended = 1;
  goto <D.22593>;
  <D.22591>:
  D.22594 = bb->last_ins;
  if (D.22594 != 0B) goto <D.22612>; else goto <D.22613>;
  <D.22612>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22597 = D.22596 + 64985;
  if (D.22597 <= 9) goto <D.22610>; else goto <D.22614>;
  <D.22614>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22599 = D.22596 + 64878;
  if (D.22599 <= 9) goto <D.22610>; else goto <D.22615>;
  <D.22615>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22601 = D.22596 + 64888;
  if (D.22601 <= 9) goto <D.22610>; else goto <D.22616>;
  <D.22616>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  if (D.22596 == 442) goto <D.22610>; else goto <D.22617>;
  <D.22617>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  if (D.22596 == 759) goto <D.22610>; else goto <D.22618>;
  <D.22618>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  if (D.22596 == 370) goto <D.22610>; else goto <D.22611>;
  <D.22610>:
  D.22594 = bb->last_ins;
  D.22594->opcode = 316;
  D.22594 = bb->last_ins;
  D.22594->dreg = -1;
  D.22594 = bb->last_ins;
  D.22594 = bb->last_ins;
  D.22594 = bb->last_ins;
  D.22594->sreg3 = -1;
  D.22619 = D.22594->sreg3;
  D.22594->sreg2 = D.22619;
  D.22620 = D.22594->sreg2;
  D.22594->sreg1 = D.22620;
  <D.22611>:
  <D.22613>:
  <D.22593>:
  D.22621 = bb->has_call_handler;
  D.22622 = bbn->has_call_handler;
  D.22623 = D.22621 | D.22622;
  bb->has_call_handler = D.22623;
  D.22624 = bb->has_jump_table;
  D.22625 = bbn->has_jump_table;
  D.22626 = D.22624 | D.22625;
  bb->has_jump_table = D.22626;
  D.22594 = bb->last_ins;
  if (D.22594 != 0B) goto <D.22627>; else goto <D.22628>;
  <D.22627>:
  D.22629 = bbn->code;
  if (D.22629 != 0B) goto <D.22630>; else goto <D.22631>;
  <D.22630>:
  D.22594 = bb->last_ins;
  D.22629 = bbn->code;
  D.22594->next = D.22629;
  D.22629 = bbn->code;
  D.22594 = bb->last_ins;
  D.22629->prev = D.22594;
  D.22632 = bbn->last_ins;
  bb->last_ins = D.22632;
  <D.22631>:
  goto <D.22633>;
  <D.22628>:
  D.22629 = bbn->code;
  bb->code = D.22629;
  D.22632 = bbn->last_ins;
  bb->last_ins = D.22632;
  <D.22633>:
  prev_bb = cfg->bb_entry;
  goto <D.22306>;
  <D.22305>:
  prev_bb = prev_bb->next_bb;
  <D.22306>:
  if (prev_bb != 0B) goto <D.22634>; else goto <D.22307>;
  <D.22634>:
  D.22635 = prev_bb->next_bb;
  if (D.22635 != bbn) goto <D.22305>; else goto <D.22307>;
  <D.22307>:
  if (prev_bb != 0B) goto <D.22636>; else goto <D.22637>;
  <D.22636>:
  D.22638 = bbn->next_bb;
  prev_bb->next_bb = D.22638;
  goto <D.22639>;
  <D.22637>:
  D.22640 = bb->next_bb;
  if (D.22640 == bbn) goto <D.22641>; else goto <D.22642>;
  <D.22641>:
  D.22638 = bbn->next_bb;
  bb->next_bb = D.22638;
  <D.22642>:
  <D.22639>:
  mono_nullify_basic_block (bbn);
  D.22594 = bb->last_ins;
  if (D.22594 != 0B) goto <D.22643>; else goto <D.22644>;
  <D.22643>:
  D.22645 = bb->out_count;
  if (D.22645 == 1) goto <D.22646>; else goto <D.22647>;
  <D.22646>:
  D.22648 = bb->out_bb;
  D.22649 = *D.22648;
  D.22640 = bb->next_bb;
  if (D.22649 != D.22640) goto <D.22650>; else goto <D.22651>;
  <D.22650>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22597 = D.22596 + 64985;
  if (D.22597 > 9) goto <D.22652>; else goto <D.22653>;
  <D.22652>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22599 = D.22596 + 64878;
  if (D.22599 > 9) goto <D.22654>; else goto <D.22655>;
  <D.22654>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  D.22601 = D.22596 + 64888;
  if (D.22601 > 9) goto <D.22656>; else goto <D.22657>;
  <D.22656>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  if (D.22596 != 442) goto <D.22658>; else goto <D.22659>;
  <D.22658>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  if (D.22596 != 759) goto <D.22660>; else goto <D.22661>;
  <D.22660>:
  D.22594 = bb->last_ins;
  D.22596 = D.22594->opcode;
  if (D.22596 != 370) goto <D.22662>; else goto <D.22663>;
  <D.22662>:
  D.22664 = cfg->mempool;
  inst = mono_mempool_alloc0 (D.22664, 80);
  inst->opcode = 442;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.22546 = inst->sreg3;
  inst->sreg2 = D.22546;
  D.22547 = inst->sreg2;
  inst->sreg1 = D.22547;
  D.22665 = cfg->ip;
  inst->cil_code = D.22665;
  D.22648 = bb->out_bb;
  D.22649 = *D.22648;
  inst->data.op[0].target_block = D.22649;
  D.22594 = bb->last_ins;
  if (D.22594 != 0B) goto <D.22666>; else goto <D.22667>;
  <D.22666>:
  D.22594 = bb->last_ins;
  D.22594->next = inst;
  D.22594 = bb->last_ins;
  inst->prev = D.22594;
  bb->last_ins = inst;
  goto <D.22668>;
  <D.22667>:
  bb->last_ins = inst;
  D.22594 = bb->last_ins;
  bb->code = D.22594;
  <D.22668>:
  <D.22663>:
  <D.22661>:
  <D.22659>:
  <D.22657>:
  <D.22655>:
  <D.22653>:
  <D.22651>:
  <D.22647>:
  <D.22644>:
}


__attribute__((visibility ("hidden")))
mono_remove_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.22670;
  _Bool D.22671;
  long int D.22672;
  long int D.22673;
  struct MonoBasicBlock * D.22676;
  struct MonoBasicBlock * tmp_bb;

  tmp_bb = cfg->bb_entry;
  goto <D.22327>;
  <D.22326>:
  tmp_bb = tmp_bb->next_bb;
  <D.22327>:
  if (tmp_bb != 0B) goto <D.22669>; else goto <D.22328>;
  <D.22669>:
  D.22670 = tmp_bb->next_bb;
  if (D.22670 != bb) goto <D.22326>; else goto <D.22328>;
  <D.22328>:
  D.22671 = tmp_bb == 0B;
  D.22672 = (long int) D.22671;
  D.22673 = __builtin_expect (D.22672, 0);
  if (D.22673 != 0) goto <D.22674>; else goto <D.22675>;
  <D.22674>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1092, "tmp_bb");
  <D.22675>:
  D.22676 = bb->next_bb;
  tmp_bb->next_bb = D.22676;
}


__attribute__((visibility ("hidden")))
mono_remove_critical_edges (struct MonoCompile * cfg)
{
  unsigned int D.22677;
  int D.22680;
  struct MonoBasicBlock * * D.22681;
  long unsigned int D.22682;
  long unsigned int D.22683;
  struct MonoBasicBlock * * D.22684;
  struct MonoBasicBlock * D.22685;
  int D.22686;
  short int D.22687;
  int D.22688;
  struct MonoBasicBlock * * D.22689;
  struct MonoBasicBlock * * D.22690;
  struct MonoBasicBlock * D.22691;
  int D.22692;
  short int D.22693;
  int D.22694;
  struct MonoInst * D.22695;
  long unsigned int D.22700;
  long unsigned int D.22701;
  struct MonoBasicBlock * * D.22702;
  short int D.22705;
  struct MonoInst * D.22708;
  short unsigned int D.22710;
  struct MonoMemPool * D.22711;
  unsigned int D.22712;
  unsigned int D.22713;
  unsigned int D.22714;
  int D.22715;
  unsigned int D.22716;
  int D.22717;
  struct MonoBasicBlock * D.22720;
  struct MonoBasicBlock * * D.22723;
  long unsigned int D.22724;
  long unsigned int D.22725;
  struct MonoBasicBlock * * D.22726;
  struct MonoBasicBlock * D.22727;
  int D.22730;
  int D.22731;
  const unsigned char * D.22732;
  struct MonoInst * D.22733;
  unsigned char * D.22737;
  short int D.22738;
  int D.22739;
  unsigned int D.22741;
  unsigned int D.22742;
  int D.22743;
  int D.22744;
  int D.22745;
  struct MonoInst * D.22746;
  unsigned char * D.22750;
  int D.22753;
  void * D.22754;
  struct MonoBasicBlock * * D.22755;
  void * D.22756;
  struct MonoBasicBlock * * D.22757;
  int D.22760;
  int D.22761;
  long unsigned int D.22764;
  long unsigned int D.22765;
  struct MonoBasicBlock * * D.22766;
  struct MonoBasicBlock * D.22767;
  int D.22768;
  struct MonoBasicBlock * * D.22769;
  struct MonoBasicBlock * D.22770;
  int D.22771;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * previous_bb;

  D.22677 = cfg->verbose_level;
  if (D.22677 > 3) goto <D.22678>; else goto <D.22679>;
  <D.22678>:
  bb = cfg->bb_entry;
  goto <D.22342>;
  <D.22341>:
  {
    int i;

    D.22680 = bb->block_num;
    printf ("remove_critical_edges, BEFORE BB%d (in:", D.22680);
    i = 0;
    goto <D.22336>;
    <D.22335>:
    D.22681 = bb->in_bb;
    D.22682 = (long unsigned int) i;
    D.22683 = D.22682 * 8;
    D.22684 = D.22681 + D.22683;
    D.22685 = *D.22684;
    D.22686 = D.22685->block_num;
    printf (" %d", D.22686);
    i = i + 1;
    <D.22336>:
    D.22687 = bb->in_count;
    D.22688 = (int) D.22687;
    if (D.22688 > i) goto <D.22335>; else goto <D.22337>;
    <D.22337>:
    printf (") (out:");
    i = 0;
    goto <D.22339>;
    <D.22338>:
    D.22689 = bb->out_bb;
    D.22682 = (long unsigned int) i;
    D.22683 = D.22682 * 8;
    D.22690 = D.22689 + D.22683;
    D.22691 = *D.22690;
    D.22692 = D.22691->block_num;
    printf (" %d", D.22692);
    i = i + 1;
    <D.22339>:
    D.22693 = bb->out_count;
    D.22694 = (int) D.22693;
    if (D.22694 > i) goto <D.22338>; else goto <D.22340>;
    <D.22340>:
    printf (")");
    D.22695 = bb->last_ins;
    if (D.22695 != 0B) goto <D.22696>; else goto <D.22697>;
    <D.22696>:
    printf (" ");
    D.22695 = bb->last_ins;
    mono_print_ins (D.22695);
    <D.22697>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.22342>:
  if (bb != 0B) goto <D.22341>; else goto <D.22343>;
  <D.22343>:
  <D.22679>:
  previous_bb = cfg->bb_entry;
  bb = previous_bb->next_bb;
  goto <D.22358>;
  <D.22357>:
  D.22687 = bb->in_count;
  if (D.22687 > 1) goto <D.22698>; else goto <D.22699>;
  <D.22698>:
  {
    int in_bb_index;

    in_bb_index = 0;
    goto <D.22355>;
    <D.22354>:
    {
      struct MonoBasicBlock * in_bb;

      D.22681 = bb->in_bb;
      D.22700 = (long unsigned int) in_bb_index;
      D.22701 = D.22700 * 8;
      D.22702 = D.22681 + D.22701;
      in_bb = *D.22702;
      D.22705 = in_bb->out_count;
      if (D.22705 > 1) goto <D.22703>; else goto <D.22706>;
      <D.22706>:
      D.22705 = in_bb->out_count;
      if (D.22705 == 1) goto <D.22707>; else goto <D.22704>;
      <D.22707>:
      D.22708 = in_bb->last_ins;
      if (D.22708 != 0B) goto <D.22709>; else goto <D.22704>;
      <D.22709>:
      D.22708 = in_bb->last_ins;
      D.22710 = D.22708->opcode;
      if (D.22710 == 759) goto <D.22703>; else goto <D.22704>;
      <D.22703>:
      {
        struct MonoBasicBlock * new_bb;

        D.22711 = cfg->mempool;
        new_bb = mono_mempool_alloc0 (D.22711, 296);
        D.22712 = cfg->num_bblocks;
        D.22713 = D.22712;
        D.22714 = D.22713 + 1;
        cfg->num_bblocks = D.22714;
        D.22715 = (int) D.22713;
        new_bb->block_num = D.22715;
        D.22716 = bb->region;
        new_bb->region = D.22716;
        D.22717 = mono_bb_is_fall_through (cfg, previous_bb);
        if (D.22717 != 0) goto <D.22718>; else goto <D.22719>;
        <D.22718>:
        D.22720 = cfg->bb_entry;
        if (D.22720 != previous_bb) goto <D.22721>; else goto <D.22722>;
        <D.22721>:
        {
          int i;

          i = 0;
          goto <D.22351>;
          <D.22350>:
          D.22723 = previous_bb->out_bb;
          D.22724 = (long unsigned int) i;
          D.22725 = D.22724 * 8;
          D.22726 = D.22723 + D.22725;
          D.22727 = *D.22726;
          if (D.22727 == bb) goto <D.22728>; else goto <D.22729>;
          <D.22728>:
          {
            struct MonoInst * jump;

            D.22711 = cfg->mempool;
            jump = mono_mempool_alloc0 (D.22711, 80);
            jump->opcode = 442;
            jump->dreg = -1;
            jump->sreg3 = -1;
            D.22730 = jump->sreg3;
            jump->sreg2 = D.22730;
            D.22731 = jump->sreg2;
            jump->sreg1 = D.22731;
            D.22732 = cfg->ip;
            jump->cil_code = D.22732;
            D.22733 = previous_bb->last_ins;
            if (D.22733 != 0B) goto <D.22734>; else goto <D.22735>;
            <D.22734>:
            D.22733 = previous_bb->last_ins;
            D.22733->next = jump;
            D.22733 = previous_bb->last_ins;
            jump->prev = D.22733;
            previous_bb->last_ins = jump;
            goto <D.22736>;
            <D.22735>:
            previous_bb->last_ins = jump;
            D.22733 = previous_bb->last_ins;
            previous_bb->code = D.22733;
            <D.22736>:
            D.22737 = previous_bb->cil_code;
            jump->cil_code = D.22737;
            jump->data.op[0].target_block = bb;
            goto <D.22349>;
          }
          <D.22729>:
          i = i + 1;
          <D.22351>:
          D.22738 = previous_bb->out_count;
          D.22739 = (int) D.22738;
          if (D.22739 > i) goto <D.22350>; else goto <D.22349>;
          <D.22349>:
        }
        goto <D.22740>;
        <D.22722>:
        {
          struct MonoInst * jump;
          struct MonoBasicBlock * new_bb_after_entry;

          D.22711 = cfg->mempool;
          new_bb_after_entry = mono_mempool_alloc0 (D.22711, 296);
          D.22712 = cfg->num_bblocks;
          D.22741 = D.22712;
          D.22742 = D.22741 + 1;
          cfg->num_bblocks = D.22742;
          D.22743 = (int) D.22741;
          new_bb_after_entry->block_num = D.22743;
          D.22716 = bb->region;
          new_bb_after_entry->region = D.22716;
          D.22711 = cfg->mempool;
          jump = mono_mempool_alloc0 (D.22711, 80);
          jump->opcode = 442;
          jump->dreg = -1;
          jump->sreg3 = -1;
          D.22744 = jump->sreg3;
          jump->sreg2 = D.22744;
          D.22745 = jump->sreg2;
          jump->sreg1 = D.22745;
          D.22732 = cfg->ip;
          jump->cil_code = D.22732;
          D.22746 = new_bb_after_entry->last_ins;
          if (D.22746 != 0B) goto <D.22747>; else goto <D.22748>;
          <D.22747>:
          D.22746 = new_bb_after_entry->last_ins;
          D.22746->next = jump;
          D.22746 = new_bb_after_entry->last_ins;
          jump->prev = D.22746;
          new_bb_after_entry->last_ins = jump;
          goto <D.22749>;
          <D.22748>:
          new_bb_after_entry->last_ins = jump;
          D.22746 = new_bb_after_entry->last_ins;
          new_bb_after_entry->code = D.22746;
          <D.22749>:
          D.22750 = bb->cil_code;
          jump->cil_code = D.22750;
          jump->data.op[0].target_block = bb;
          mono_unlink_bblock (cfg, previous_bb, bb);
          mono_link_bblock (cfg, new_bb_after_entry, bb);
          mono_link_bblock (cfg, previous_bb, new_bb_after_entry);
          previous_bb->next_bb = new_bb_after_entry;
          previous_bb = new_bb_after_entry;
          D.22677 = cfg->verbose_level;
          if (D.22677 > 2) goto <D.22751>; else goto <D.22752>;
          <D.22751>:
          D.22753 = new_bb_after_entry->block_num;
          D.22680 = bb->block_num;
          printf ("remove_critical_edges, added helper BB%d jumping to BB%d\n", D.22753, D.22680);
          <D.22752>:
        }
        <D.22740>:
        <D.22719>:
        previous_bb->next_bb = new_bb;
        new_bb->next_bb = bb;
        previous_bb = new_bb;
        D.22711 = cfg->mempool;
        D.22754 = mono_mempool_alloc (D.22711, 8);
        new_bb->in_bb = D.22754;
        D.22755 = new_bb->in_bb;
        *D.22755 = in_bb;
        new_bb->in_count = 1;
        D.22711 = cfg->mempool;
        D.22756 = mono_mempool_alloc (D.22711, 8);
        new_bb->out_bb = D.22756;
        D.22757 = new_bb->out_bb;
        *D.22757 = bb;
        new_bb->out_count = 1;
        replace_out_block (in_bb, bb, new_bb);
        replace_out_block_in_code (in_bb, bb, new_bb);
        replace_in_block (bb, in_bb, new_bb);
        D.22677 = cfg->verbose_level;
        if (D.22677 > 2) goto <D.22758>; else goto <D.22759>;
        <D.22758>:
        D.22760 = in_bb->block_num;
        D.22680 = bb->block_num;
        D.22761 = new_bb->block_num;
        printf ("remove_critical_edges, removed critical edge from BB%d to BB%d (added BB%d)\n", D.22760, D.22680, D.22761);
        <D.22759>:
      }
      <D.22704>:
    }
    in_bb_index = in_bb_index + 1;
    <D.22355>:
    D.22687 = bb->in_count;
    D.22688 = (int) D.22687;
    if (D.22688 > in_bb_index) goto <D.22354>; else goto <D.22356>;
    <D.22356>:
  }
  <D.22699>:
  previous_bb = previous_bb->next_bb;
  bb = bb->next_bb;
  <D.22358>:
  if (bb != 0B) goto <D.22357>; else goto <D.22359>;
  <D.22359>:
  D.22677 = cfg->verbose_level;
  if (D.22677 > 3) goto <D.22762>; else goto <D.22763>;
  <D.22762>:
  bb = cfg->bb_entry;
  goto <D.22368>;
  <D.22367>:
  {
    int i;

    D.22680 = bb->block_num;
    printf ("remove_critical_edges, AFTER BB%d (in:", D.22680);
    i = 0;
    goto <D.22362>;
    <D.22361>:
    D.22681 = bb->in_bb;
    D.22764 = (long unsigned int) i;
    D.22765 = D.22764 * 8;
    D.22766 = D.22681 + D.22765;
    D.22767 = *D.22766;
    D.22768 = D.22767->block_num;
    printf (" %d", D.22768);
    i = i + 1;
    <D.22362>:
    D.22687 = bb->in_count;
    D.22688 = (int) D.22687;
    if (D.22688 > i) goto <D.22361>; else goto <D.22363>;
    <D.22363>:
    printf (") (out:");
    i = 0;
    goto <D.22365>;
    <D.22364>:
    D.22689 = bb->out_bb;
    D.22764 = (long unsigned int) i;
    D.22765 = D.22764 * 8;
    D.22769 = D.22689 + D.22765;
    D.22770 = *D.22769;
    D.22771 = D.22770->block_num;
    printf (" %d", D.22771);
    i = i + 1;
    <D.22365>:
    D.22693 = bb->out_count;
    D.22694 = (int) D.22693;
    if (D.22694 > i) goto <D.22364>; else goto <D.22366>;
    <D.22366>:
    printf (")");
    D.22695 = bb->last_ins;
    if (D.22695 != 0B) goto <D.22772>; else goto <D.22773>;
    <D.22772>:
    printf (" ");
    D.22695 = bb->last_ins;
    mono_print_ins (D.22695);
    <D.22773>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.22368>:
  if (bb != 0B) goto <D.22367>; else goto <D.22369>;
  <D.22369>:
  <D.22763>:
}


mono_bb_is_fall_through (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  gboolean D.22774;
  int iftmp.4;
  struct MonoBasicBlock * D.22779;
  unsigned int D.22781;
  unsigned int D.22782;
  struct MonoInst * D.22784;
  short unsigned int D.22786;
  short unsigned int D.22787;
  short unsigned int D.22789;
  short unsigned int D.22791;

  D.22779 = bb->next_bb;
  if (D.22779 != 0B) goto <D.22780>; else goto <D.22776>;
  <D.22780>:
  D.22779 = bb->next_bb;
  D.22781 = D.22779->region;
  D.22782 = bb->region;
  if (D.22781 == D.22782) goto <D.22783>; else goto <D.22776>;
  <D.22783>:
  D.22784 = bb->last_ins;
  if (D.22784 == 0B) goto <D.22777>; else goto <D.22785>;
  <D.22785>:
  D.22784 = bb->last_ins;
  D.22786 = D.22784->opcode;
  D.22787 = D.22786 + 64985;
  if (D.22787 > 9) goto <D.22788>; else goto <D.22776>;
  <D.22788>:
  D.22784 = bb->last_ins;
  D.22786 = D.22784->opcode;
  D.22789 = D.22786 + 64878;
  if (D.22789 > 9) goto <D.22790>; else goto <D.22776>;
  <D.22790>:
  D.22784 = bb->last_ins;
  D.22786 = D.22784->opcode;
  D.22791 = D.22786 + 64888;
  if (D.22791 > 9) goto <D.22792>; else goto <D.22776>;
  <D.22792>:
  D.22784 = bb->last_ins;
  D.22786 = D.22784->opcode;
  if (D.22786 != 442) goto <D.22793>; else goto <D.22776>;
  <D.22793>:
  D.22784 = bb->last_ins;
  D.22786 = D.22784->opcode;
  if (D.22786 != 759) goto <D.22794>; else goto <D.22776>;
  <D.22794>:
  D.22784 = bb->last_ins;
  D.22786 = D.22784->opcode;
  if (D.22786 != 370) goto <D.22777>; else goto <D.22776>;
  <D.22777>:
  iftmp.4 = 1;
  goto <D.22778>;
  <D.22776>:
  iftmp.4 = 0;
  <D.22778>:
  D.22774 = iftmp.4;
  return D.22774;
}


replace_out_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.22796;
  long unsigned int D.22797;
  long unsigned int D.22798;
  struct MonoBasicBlock * * D.22799;
  short int D.22804;
  long unsigned int D.22807;
  long unsigned int D.22808;
  sizetype D.22809;
  struct MonoBasicBlock * * D.22810;
  struct MonoBasicBlock * D.22811;
  short int D.22812;
  unsigned short D.22813;
  unsigned short D.22814;
  short int D.22815;
  int D.22817;
  int i;

  i = 0;
  goto <D.22221>;
  <D.22220>:
  {
    struct MonoBasicBlock * ob;

    D.22796 = bb->out_bb;
    D.22797 = (long unsigned int) i;
    D.22798 = D.22797 * 8;
    D.22799 = D.22796 + D.22798;
    ob = *D.22799;
    if (ob == orig) goto <D.22800>; else goto <D.22801>;
    <D.22800>:
    if (repl == 0B) goto <D.22802>; else goto <D.22803>;
    <D.22802>:
    D.22804 = bb->out_count;
    if (D.22804 > 1) goto <D.22805>; else goto <D.22806>;
    <D.22805>:
    D.22796 = bb->out_bb;
    D.22797 = (long unsigned int) i;
    D.22798 = D.22797 * 8;
    D.22799 = D.22796 + D.22798;
    D.22796 = bb->out_bb;
    D.22804 = bb->out_count;
    D.22807 = (long unsigned int) D.22804;
    D.22808 = D.22807 * 8;
    D.22809 = D.22808 + 18446744073709551608;
    D.22810 = D.22796 + D.22809;
    D.22811 = *D.22810;
    *D.22799 = D.22811;
    <D.22806>:
    D.22804 = bb->out_count;
    D.22812 = D.22804;
    D.22813 = (unsigned short) D.22812;
    D.22814 = D.22813 + 65535;
    D.22815 = (short int) D.22814;
    bb->out_count = D.22815;
    goto <D.22816>;
    <D.22803>:
    D.22796 = bb->out_bb;
    D.22797 = (long unsigned int) i;
    D.22798 = D.22797 * 8;
    D.22799 = D.22796 + D.22798;
    *D.22799 = repl;
    <D.22816>:
    <D.22801>:
  }
  i = i + 1;
  <D.22221>:
  D.22804 = bb->out_count;
  D.22817 = (int) D.22804;
  if (D.22817 > i) goto <D.22220>; else goto <D.22222>;
  <D.22222>:
}


replace_out_block_in_code (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  short unsigned int D.22818;
  int D.22819;
  struct MonoBasicBlock * D.22820;
  struct MonoClass * D.22825;
  long int D.22826;
  struct MonoBasicBlock * * D.22827;
  long unsigned int D.22828;
  long unsigned int D.22829;
  struct MonoBasicBlock * * D.22830;
  struct MonoBasicBlock * D.22831;
  short unsigned int D.22837;
  short unsigned int D.22839;
  short unsigned int D.22841;
  struct MonoBasicBlock * D.22842;
  struct MonoBasicBlock * * D.22845;
  struct MonoBasicBlock * D.22846;
  struct MonoInst * D.22854;
  struct MonoInst * D.22857;
  struct MonoJumpInfoBBTable * iftmp.5;
  struct MonoJumpInfoBBTable * iftmp.6;
  struct MonoJumpInfoBBTable * iftmp.7;
  struct MonoJumpInfoBBTable * iftmp.8;
  struct MonoBasicBlock * * D.22876;
  long unsigned int D.22877;
  long unsigned int D.22878;
  struct MonoBasicBlock * * D.22879;
  struct MonoBasicBlock * D.22880;
  int D.22883;
  struct MonoInst * ins;

  ins = bb->code;
  goto <D.22255>;
  <D.22254>:
  D.22818 = ins->opcode;
  D.22819 = (int) D.22818;
  switch (D.22819) <default: <D.22248>, case 370: <D.22242>, case 442: <D.22239>, case 735: <D.22241>>
  <D.22239>:
  D.22820 = ins->data.op[0].target_block;
  if (D.22820 == orig) goto <D.22821>; else goto <D.22822>;
  <D.22821>:
  ins->data.op[0].target_block = repl;
  <D.22822>:
  goto <D.22240>;
  <D.22241>:
  D.22820 = ins->data.op[0].target_block;
  if (D.22820 == orig) goto <D.22823>; else goto <D.22824>;
  <D.22823>:
  ins->data.op[0].target_block = repl;
  <D.22824>:
  goto <D.22240>;
  <D.22242>:
  {
    int i;
    int n;

    D.22825 = ins->klass;
    D.22826 = (long int) D.22825;
    n = (int) D.22826;
    i = 0;
    goto <D.22246>;
    <D.22245>:
    D.22827 = ins->data.op[1].many_blocks;
    D.22828 = (long unsigned int) i;
    D.22829 = D.22828 * 8;
    D.22830 = D.22827 + D.22829;
    D.22831 = *D.22830;
    if (D.22831 == orig) goto <D.22832>; else goto <D.22833>;
    <D.22832>:
    D.22827 = ins->data.op[1].many_blocks;
    D.22828 = (long unsigned int) i;
    D.22829 = D.22828 * 8;
    D.22830 = D.22827 + D.22829;
    *D.22830 = repl;
    <D.22833>:
    i = i + 1;
    <D.22246>:
    if (i < n) goto <D.22245>; else goto <D.22247>;
    <D.22247>:
    goto <D.22240>;
  }
  <D.22248>:
  D.22818 = ins->opcode;
  D.22837 = D.22818 + 64985;
  if (D.22837 <= 9) goto <D.22834>; else goto <D.22838>;
  <D.22838>:
  D.22818 = ins->opcode;
  D.22839 = D.22818 + 64878;
  if (D.22839 <= 9) goto <D.22834>; else goto <D.22840>;
  <D.22840>:
  D.22818 = ins->opcode;
  D.22841 = D.22818 + 64888;
  if (D.22841 <= 9) goto <D.22834>; else goto <D.22835>;
  <D.22834>:
  D.22827 = ins->data.op[1].many_blocks;
  D.22842 = *D.22827;
  if (D.22842 == orig) goto <D.22843>; else goto <D.22844>;
  <D.22843>:
  D.22827 = ins->data.op[1].many_blocks;
  *D.22827 = repl;
  <D.22844>:
  D.22827 = ins->data.op[1].many_blocks;
  D.22845 = D.22827 + 8;
  D.22846 = *D.22845;
  if (D.22846 == orig) goto <D.22847>; else goto <D.22848>;
  <D.22847>:
  D.22827 = ins->data.op[1].many_blocks;
  D.22845 = D.22827 + 8;
  *D.22845 = repl;
  <D.22848>:
  goto <D.22836>;
  <D.22835>:
  D.22818 = ins->opcode;
  if (D.22818 == 731) goto <D.22849>; else goto <D.22852>;
  <D.22852>:
  D.22818 = ins->opcode;
  if (D.22818 == 732) goto <D.22853>; else goto <D.22850>;
  <D.22853>:
  D.22854 = ins->data.op[1].src;
  if (D.22854 == 8B) goto <D.22849>; else goto <D.22850>;
  <D.22850>:
  D.22818 = ins->opcode;
  if (D.22818 == 370) goto <D.22849>; else goto <D.22855>;
  <D.22855>:
  D.22818 = ins->opcode;
  if (D.22818 == 734) goto <D.22856>; else goto <D.22851>;
  <D.22856>:
  D.22854 = ins->data.op[1].src;
  D.22857 = D.22854->data.op[1].src;
  if (D.22857 == 8B) goto <D.22849>; else goto <D.22851>;
  <D.22849>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.22818 = ins->opcode;
    if (D.22818 == 731) goto <D.22859>; else goto <D.22860>;
    <D.22859>:
    iftmp.5 = ins->data.op[0].p;
    goto <D.22861>;
    <D.22860>:
    D.22818 = ins->opcode;
    if (D.22818 == 732) goto <D.22865>; else goto <D.22863>;
    <D.22865>:
    D.22854 = ins->data.op[1].src;
    if (D.22854 == 8B) goto <D.22866>; else goto <D.22863>;
    <D.22866>:
    iftmp.6 = ins->data.op[0].p;
    goto <D.22864>;
    <D.22863>:
    D.22818 = ins->opcode;
    if (D.22818 == 370) goto <D.22868>; else goto <D.22869>;
    <D.22868>:
    iftmp.7 = ins->data.op[0].p;
    goto <D.22870>;
    <D.22869>:
    D.22818 = ins->opcode;
    if (D.22818 == 734) goto <D.22874>; else goto <D.22872>;
    <D.22874>:
    D.22854 = ins->data.op[1].src;
    D.22857 = D.22854->data.op[1].src;
    if (D.22857 == 8B) goto <D.22875>; else goto <D.22872>;
    <D.22875>:
    D.22854 = ins->data.op[1].src;
    iftmp.8 = D.22854->data.op[0].p;
    goto <D.22873>;
    <D.22872>:
    iftmp.8 = 0B;
    <D.22873>:
    iftmp.7 = iftmp.8;
    <D.22870>:
    iftmp.6 = iftmp.7;
    <D.22864>:
    iftmp.5 = iftmp.6;
    <D.22861>:
    table = iftmp.5;
    i = 0;
    goto <D.22252>;
    <D.22251>:
    D.22876 = table->table;
    D.22877 = (long unsigned int) i;
    D.22878 = D.22877 * 8;
    D.22879 = D.22876 + D.22878;
    D.22880 = *D.22879;
    if (D.22880 == orig) goto <D.22881>; else goto <D.22882>;
    <D.22881>:
    D.22876 = table->table;
    D.22877 = (long unsigned int) i;
    D.22878 = D.22877 * 8;
    D.22879 = D.22876 + D.22878;
    *D.22879 = repl;
    <D.22882>:
    i = i + 1;
    <D.22252>:
    D.22883 = table->table_size;
    if (D.22883 > i) goto <D.22251>; else goto <D.22253>;
    <D.22253>:
  }
  <D.22851>:
  <D.22836>:
  goto <D.22240>;
  <D.22240>:
  ins = ins->next;
  <D.22255>:
  if (ins != 0B) goto <D.22254>; else goto <D.22256>;
  <D.22256>:
}


replace_in_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.22884;
  long unsigned int D.22885;
  long unsigned int D.22886;
  struct MonoBasicBlock * * D.22887;
  short int D.22892;
  long unsigned int D.22895;
  long unsigned int D.22896;
  sizetype D.22897;
  struct MonoBasicBlock * * D.22898;
  struct MonoBasicBlock * D.22899;
  short int D.22900;
  unsigned short D.22901;
  unsigned short D.22902;
  short int D.22903;
  int D.22905;
  int i;

  i = 0;
  goto <D.22231>;
  <D.22230>:
  {
    struct MonoBasicBlock * ib;

    D.22884 = bb->in_bb;
    D.22885 = (long unsigned int) i;
    D.22886 = D.22885 * 8;
    D.22887 = D.22884 + D.22886;
    ib = *D.22887;
    if (ib == orig) goto <D.22888>; else goto <D.22889>;
    <D.22888>:
    if (repl == 0B) goto <D.22890>; else goto <D.22891>;
    <D.22890>:
    D.22892 = bb->in_count;
    if (D.22892 > 1) goto <D.22893>; else goto <D.22894>;
    <D.22893>:
    D.22884 = bb->in_bb;
    D.22885 = (long unsigned int) i;
    D.22886 = D.22885 * 8;
    D.22887 = D.22884 + D.22886;
    D.22884 = bb->in_bb;
    D.22892 = bb->in_count;
    D.22895 = (long unsigned int) D.22892;
    D.22896 = D.22895 * 8;
    D.22897 = D.22896 + 18446744073709551608;
    D.22898 = D.22884 + D.22897;
    D.22899 = *D.22898;
    *D.22887 = D.22899;
    <D.22894>:
    D.22892 = bb->in_count;
    D.22900 = D.22892;
    D.22901 = (unsigned short) D.22900;
    D.22902 = D.22901 + 65535;
    D.22903 = (short int) D.22902;
    bb->in_count = D.22903;
    goto <D.22904>;
    <D.22891>:
    D.22884 = bb->in_bb;
    D.22885 = (long unsigned int) i;
    D.22886 = D.22885 * 8;
    D.22887 = D.22884 + D.22886;
    *D.22887 = repl;
    <D.22904>:
    <D.22889>:
  }
  i = i + 1;
  <D.22231>:
  D.22892 = bb->in_count;
  D.22905 = (int) D.22892;
  if (D.22905 > i) goto <D.22230>; else goto <D.22232>;
  <D.22232>:
}


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

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


__attribute__((visibility ("hidden")))
mono_optimize_branches (struct MonoCompile * cfg)
{
  unsigned int D.22908;
  struct MonoBasicBlock * D.22912;
  unsigned int D.22913;
  long unsigned int D.22916;
  long unsigned int D.22917;
  int D.22920;
  short int D.22925;
  struct MonoBasicBlock * D.22928;
  unsigned int D.22931;
  unsigned int D.22934;
  int D.22937;
  struct MonoBasicBlock * D.22938;
  struct MonoBasicBlock * * D.22939;
  long unsigned int D.22940;
  long unsigned int D.22941;
  struct MonoBasicBlock * * D.22942;
  struct MonoBasicBlock * D.22943;
  short int D.22944;
  int D.22945;
  short int D.22946;
  struct MonoBasicBlock * * D.22949;
  struct MonoInst * D.22952;
  short unsigned int D.22955;
  short unsigned int D.22958;
  short unsigned int D.22960;
  short unsigned int D.22962;
  struct MonoBasicBlock * * D.22963;
  struct MonoBasicBlock * D.22964;
  int D.22967;
  int D.22968;
  struct MonoBasicBlock * D.22971;
  long unsigned int D.22978;
  long unsigned int D.22979;
  long unsigned int D.22986;
  struct MonoInst * D.23011;
  short unsigned int D.23014;
  struct MonoBasicBlock * D.23017;
  unsigned int D.23020;
  int D.23025;
  struct MonoInst * D.23039;
  struct MonoInst * D.23041;
  unsigned char D.23042;
  unsigned char D.23043;
  int D.23044;
  int D.23045;
  int D.23049;
  int D.23072;
  struct MonoBasicBlock * * D.23073;
  struct MonoBasicBlock * D.23074;
  long unsigned int D.23093;
  long unsigned int D.23094;
  int D.23103;
  struct MonoBasicBlock * * D.23106;
  struct MonoBasicBlock * D.23107;
  _Bool D.23108;
  long int D.23109;
  long int D.23110;
  long unsigned int D.23128;
  long unsigned int D.23129;
  unsigned int D.23132;
  long unsigned int D.23135;
  unsigned int D.23138;
  unsigned int D.23139;
  short unsigned int D.23140;
  int i;
  int changed;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * bbn;
  guint32 niterations;

  changed = 0;
  D.22908 = cfg->num_bblocks;
  if (D.22908 > 1000) goto <D.22909>; else goto <D.22910>;
  <D.22909>:
  D.22908 = cfg->num_bblocks;
  niterations = D.22908 * 2;
  goto <D.22911>;
  <D.22910>:
  niterations = 1000;
  <D.22911>:
  <D.22392>:
  {
    struct MonoBasicBlock * previous_bb;

    changed = 0;
    niterations = niterations + 4294967295;
    previous_bb = cfg->bb_entry;
    D.22912 = cfg->bb_entry;
    bb = D.22912->next_bb;
    goto <D.22390>;
    <D.22389>:
    D.22913 = bb->region;
    if (D.22913 != 4294967295) goto <D.22914>; else goto <D.22915>;
    <D.22914>:
    // predicted unlikely by continue predictor.
    goto <D.22379>;
    <D.22915>:
    D.22916 = BIT_FIELD_REF <*bb, 64, 1472>;
    D.22917 = D.22916 & 70368744177664;
    if (D.22917 == 0) goto <D.22918>; else goto <D.22919>;
    <D.22918>:
    D.22920 = remove_block_if_useless (cfg, bb, previous_bb);
    if (D.22920 != 0) goto <D.22921>; else goto <D.22922>;
    <D.22921>:
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22379>;
    <D.22922>:
    <D.22919>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.22923>; else goto <D.22924>;
    <D.22923>:
    D.22925 = bbn->in_count;
    if (D.22925 == 0) goto <D.22926>; else goto <D.22927>;
    <D.22926>:
    D.22928 = cfg->bb_exit;
    if (D.22928 != bbn) goto <D.22929>; else goto <D.22930>;
    <D.22929>:
    D.22913 = bb->region;
    D.22931 = bbn->region;
    if (D.22913 == D.22931) goto <D.22932>; else goto <D.22933>;
    <D.22932>:
    D.22934 = cfg->verbose_level;
    if (D.22934 > 2) goto <D.22935>; else goto <D.22936>;
    <D.22935>:
    D.22937 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.22937);
    <D.22936>:
    D.22938 = bbn->next_bb;
    bb->next_bb = D.22938;
    i = 0;
    goto <D.22381>;
    <D.22380>:
    D.22939 = bbn->out_bb;
    D.22940 = (long unsigned int) i;
    D.22941 = D.22940 * 8;
    D.22942 = D.22939 + D.22941;
    D.22943 = *D.22942;
    replace_in_block (D.22943, bbn, 0B);
    i = i + 1;
    <D.22381>:
    D.22944 = bbn->out_count;
    D.22945 = (int) D.22944;
    if (D.22945 > i) goto <D.22380>; else goto <D.22382>;
    <D.22382>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    <D.22933>:
    <D.22930>:
    <D.22927>:
    <D.22924>:
    D.22946 = bb->out_count;
    if (D.22946 == 1) goto <D.22947>; else goto <D.22948>;
    <D.22947>:
    D.22949 = bb->out_bb;
    bbn = *D.22949;
    D.22952 = bb->last_ins;
    if (D.22952 != 0B) goto <D.22953>; else goto <D.22954>;
    <D.22953>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    if (D.22955 != 442) goto <D.22956>; else goto <D.22957>;
    <D.22956>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22958 = D.22955 + 64985;
    if (D.22958 <= 9) goto <D.22950>; else goto <D.22959>;
    <D.22959>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22960 = D.22955 + 64878;
    if (D.22960 <= 9) goto <D.22950>; else goto <D.22961>;
    <D.22961>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22962 = D.22955 + 64888;
    if (D.22962 <= 9) goto <D.22950>; else goto <D.22951>;
    <D.22950>:
    D.22952 = bb->last_ins;
    D.22952->opcode = 442;
    D.22952 = bb->last_ins;
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    D.22964 = *D.22963;
    D.22952->data.op[0].target_block = D.22964;
    changed = 1;
    D.22934 = cfg->verbose_level;
    if (D.22934 > 2) goto <D.22965>; else goto <D.22966>;
    <D.22965>:
    D.22967 = bb->block_num;
    D.22946 = bb->out_count;
    D.22968 = (int) D.22946;
    monoeg_g_print ("cond branch removal triggered in %d %d\n", D.22967, D.22968);
    <D.22966>:
    <D.22951>:
    <D.22957>:
    <D.22954>:
    D.22913 = bb->region;
    D.22931 = bbn->region;
    if (D.22913 == D.22931) goto <D.22969>; else goto <D.22970>;
    <D.22969>:
    D.22971 = bb->next_bb;
    if (D.22971 == bbn) goto <D.22972>; else goto <D.22973>;
    <D.22972>:
    D.22952 = bb->last_ins;
    if (D.22952 != 0B) goto <D.22974>; else goto <D.22975>;
    <D.22974>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    if (D.22955 == 442) goto <D.22976>; else goto <D.22977>;
    <D.22976>:
    D.22978 = BIT_FIELD_REF <*bbn, 64, 1472>;
    D.22979 = D.22978 & 140737488355328;
    if (D.22979 == 0) goto <D.22980>; else goto <D.22981>;
    <D.22980>:
    D.22952 = bb->last_ins;
    D.22952->opcode = 316;
    changed = 1;
    D.22934 = cfg->verbose_level;
    if (D.22934 > 2) goto <D.22982>; else goto <D.22983>;
    <D.22982>:
    D.22967 = bb->block_num;
    D.22937 = bbn->block_num;
    monoeg_g_print ("br removal triggered %d -> %d\n", D.22967, D.22937);
    <D.22983>:
    <D.22981>:
    <D.22977>:
    <D.22975>:
    D.22925 = bbn->in_count;
    if (D.22925 == 1) goto <D.22984>; else goto <D.22985>;
    <D.22984>:
    D.22916 = BIT_FIELD_REF <*bb, 64, 1472>;
    D.22986 = D.22916 & 17592186044416;
    if (D.22986 == 0) goto <D.22987>; else goto <D.22988>;
    <D.22987>:
    D.22928 = cfg->bb_exit;
    if (D.22928 != bbn) goto <D.22989>; else goto <D.22990>;
    <D.22989>:
    D.22934 = cfg->verbose_level;
    if (D.22934 > 2) goto <D.22991>; else goto <D.22992>;
    <D.22991>:
    D.22967 = bb->block_num;
    D.22937 = bbn->block_num;
    monoeg_g_print ("block merge triggered %d -> %d\n", D.22967, D.22937);
    <D.22992>:
    mono_merge_basic_blocks (cfg, bb, bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22379>;
    <D.22990>:
    <D.22988>:
    <D.22985>:
    <D.22973>:
    <D.22970>:
    <D.22948>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.22993>; else goto <D.22994>;
    <D.22993>:
    D.22925 = bbn->in_count;
    if (D.22925 == 0) goto <D.22995>; else goto <D.22996>;
    <D.22995>:
    D.22928 = cfg->bb_exit;
    if (D.22928 != bbn) goto <D.22997>; else goto <D.22998>;
    <D.22997>:
    D.22913 = bb->region;
    D.22931 = bbn->region;
    if (D.22913 == D.22931) goto <D.22999>; else goto <D.23000>;
    <D.22999>:
    D.22934 = cfg->verbose_level;
    if (D.22934 > 2) goto <D.23001>; else goto <D.23002>;
    <D.23001>:
    D.22937 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.22937);
    <D.23002>:
    D.22938 = bbn->next_bb;
    bb->next_bb = D.22938;
    i = 0;
    goto <D.22384>;
    <D.22383>:
    D.22939 = bbn->out_bb;
    D.22940 = (long unsigned int) i;
    D.22941 = D.22940 * 8;
    D.22942 = D.22939 + D.22941;
    D.22943 = *D.22942;
    replace_in_block (D.22943, bbn, 0B);
    i = i + 1;
    <D.22384>:
    D.22944 = bbn->out_count;
    D.22945 = (int) D.22944;
    if (D.22945 > i) goto <D.22383>; else goto <D.22385>;
    <D.22385>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22379>;
    <D.23000>:
    <D.22998>:
    <D.22996>:
    <D.22994>:
    D.22946 = bb->out_count;
    if (D.22946 == 1) goto <D.23003>; else goto <D.23004>;
    <D.23003>:
    D.22949 = bb->out_bb;
    bbn = *D.22949;
    D.22952 = bb->last_ins;
    if (D.22952 != 0B) goto <D.23005>; else goto <D.23006>;
    <D.23005>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    if (D.22955 == 442) goto <D.23007>; else goto <D.23008>;
    <D.23007>:
    D.22952 = bb->last_ins;
    bbn = D.22952->data.op[0].target_block;
    D.22913 = bb->region;
    D.22931 = bbn->region;
    if (D.22913 == D.22931) goto <D.23009>; else goto <D.23010>;
    <D.23009>:
    D.23011 = bbn->code;
    if (D.23011 != 0B) goto <D.23012>; else goto <D.23013>;
    <D.23012>:
    D.23011 = bbn->code;
    D.23014 = D.23011->opcode;
    if (D.23014 == 442) goto <D.23015>; else goto <D.23016>;
    <D.23015>:
    D.23011 = bbn->code;
    D.23017 = D.23011->data.op[0].target_block;
    if (D.23017 != bbn) goto <D.23018>; else goto <D.23019>;
    <D.23018>:
    D.23011 = bbn->code;
    D.23017 = D.23011->data.op[0].target_block;
    D.23020 = D.23017->region;
    D.22913 = bb->region;
    if (D.23020 == D.22913) goto <D.23021>; else goto <D.23022>;
    <D.23021>:
    D.22934 = cfg->verbose_level;
    if (D.22934 > 2) goto <D.23023>; else goto <D.23024>;
    <D.23023>:
    D.22967 = bb->block_num;
    D.22937 = bbn->block_num;
    D.23011 = bbn->code;
    D.23017 = D.23011->data.op[0].target_block;
    D.23025 = D.23017->block_num;
    monoeg_g_print ("branch to branch triggered %d -> %d -> %d\n", D.22967, D.22937, D.23025);
    <D.23024>:
    replace_in_block (bbn, bb, 0B);
    D.23011 = bbn->code;
    D.23017 = D.23011->data.op[0].target_block;
    replace_out_block (bb, bbn, D.23017);
    D.23011 = bbn->code;
    D.23017 = D.23011->data.op[0].target_block;
    mono_link_bblock (cfg, bb, D.23017);
    D.22952 = bb->last_ins;
    D.23011 = bbn->code;
    D.23017 = D.23011->data.op[0].target_block;
    D.22952->data.op[0].target_block = D.23017;
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22379>;
    <D.23022>:
    <D.23019>:
    <D.23016>:
    <D.23013>:
    <D.23010>:
    <D.23008>:
    <D.23006>:
    goto <D.23026>;
    <D.23004>:
    D.22946 = bb->out_count;
    if (D.22946 == 2) goto <D.23027>; else goto <D.23028>;
    <D.23027>:
    D.22952 = bb->last_ins;
    if (D.22952 != 0B) goto <D.23033>; else goto <D.23034>;
    <D.23033>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22958 = D.22955 + 64985;
    if (D.22958 <= 9) goto <D.23031>; else goto <D.23035>;
    <D.23035>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22960 = D.22955 + 64878;
    if (D.22960 <= 9) goto <D.23031>; else goto <D.23036>;
    <D.23036>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22962 = D.22955 + 64888;
    if (D.22962 <= 9) goto <D.23031>; else goto <D.23032>;
    <D.23031>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22960 = D.22955 + 64878;
    if (D.22960 > 9) goto <D.23037>; else goto <D.23038>;
    <D.23037>:
    D.22952 = bb->last_ins;
    D.23039 = D.22952->data.op[0].src;
    if (D.23039 == 0B) goto <D.23029>; else goto <D.23040>;
    <D.23040>:
    D.22952 = bb->last_ins;
    D.23039 = D.22952->data.op[0].src;
    D.23041 = D.23039->data.op[0].src;
    D.23042 = D.23041->type;
    if (D.23042 != 4) goto <D.23029>; else goto <D.23030>;
    <D.23029>:
    {
      int branch_result;
      struct MonoBasicBlock * taken_branch_target;
      struct MonoBasicBlock * untaken_branch_target;

      taken_branch_target = 0B;
      untaken_branch_target = 0B;
      D.22952 = bb->last_ins;
      D.23043 = D.22952->flags;
      D.23044 = (int) D.23043;
      D.23045 = D.23044 & 8;
      if (D.23045 != 0) goto <D.23046>; else goto <D.23047>;
      <D.23046>:
      branch_result = 1;
      goto <D.23048>;
      <D.23047>:
      D.22952 = bb->last_ins;
      D.23043 = D.22952->flags;
      D.23044 = (int) D.23043;
      D.23049 = D.23044 & 16;
      if (D.23049 != 0) goto <D.23050>; else goto <D.23051>;
      <D.23050>:
      branch_result = 0;
      goto <D.23052>;
      <D.23051>:
      branch_result = 2;
      <D.23052>:
      <D.23048>:
      if (branch_result == 1) goto <D.23053>; else goto <D.23054>;
      <D.23053>:
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      taken_branch_target = *D.22963;
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      untaken_branch_target = MEM[(struct MonoBasicBlock * *)D.22963 + 8B];
      goto <D.23055>;
      <D.23054>:
      if (branch_result == 0) goto <D.23056>; else goto <D.23057>;
      <D.23056>:
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      taken_branch_target = MEM[(struct MonoBasicBlock * *)D.22963 + 8B];
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      untaken_branch_target = *D.22963;
      <D.23057>:
      <D.23055>:
      if (taken_branch_target != 0B) goto <D.23058>; else goto <D.23059>;
      <D.23058>:
      D.22952 = bb->last_ins;
      D.22952->opcode = 442;
      D.22952 = bb->last_ins;
      D.22952->data.op[0].target_block = taken_branch_target;
      D.22916 = BIT_FIELD_REF <*bb, 64, 1472>;
      D.22986 = D.22916 & 17592186044416;
      if (D.22986 == 0) goto <D.23060>; else goto <D.23061>;
      <D.23060>:
      mono_unlink_bblock (cfg, bb, untaken_branch_target);
      <D.23061>:
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22379>;
      <D.23059>:
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      bbn = *D.22963;
      D.22913 = bb->region;
      D.22931 = bbn->region;
      if (D.22913 == D.22931) goto <D.23062>; else goto <D.23063>;
      <D.23062>:
      D.23011 = bbn->code;
      if (D.23011 != 0B) goto <D.23064>; else goto <D.23065>;
      <D.23064>:
      D.23011 = bbn->code;
      D.23014 = D.23011->opcode;
      if (D.23014 == 442) goto <D.23066>; else goto <D.23067>;
      <D.23066>:
      D.23011 = bbn->code;
      D.23017 = D.23011->data.op[0].target_block;
      D.23020 = D.23017->region;
      D.22913 = bb->region;
      if (D.23020 == D.22913) goto <D.23068>; else goto <D.23069>;
      <D.23068>:
      D.22934 = cfg->verbose_level;
      if (D.22934 > 2) goto <D.23070>; else goto <D.23071>;
      <D.23070>:
      D.22967 = bb->block_num;
      D.22937 = bbn->block_num;
      D.23011 = bbn->code;
      D.23017 = D.23011->data.op[0].target_block;
      D.23025 = D.23017->block_num;
      D.23011 = bbn->code;
      D.23014 = D.23011->opcode;
      D.23072 = (int) D.23014;
      monoeg_g_print ("cbranch1 to branch triggered %d -> (%d) %d (0x%02x)\n", D.22967, D.22937, D.23025, D.23072);
      <D.23071>:
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.22964 = *D.22963;
      mono_unlink_bblock (cfg, bb, D.22964);
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.23073 = D.22963 + 8;
      D.23074 = *D.23073;
      mono_unlink_bblock (cfg, bb, D.23074);
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.23011 = bbn->code;
      D.23017 = D.23011->data.op[0].target_block;
      *D.22963 = D.23017;
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.22964 = *D.22963;
      mono_link_bblock (cfg, bb, D.22964);
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.23073 = D.22963 + 8;
      D.23074 = *D.23073;
      mono_link_bblock (cfg, bb, D.23074);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22379>;
      <D.23069>:
      <D.23067>:
      <D.23065>:
      <D.23063>:
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.22963 + 8B];
      if (bbn != 0B) goto <D.23075>; else goto <D.23076>;
      <D.23075>:
      D.22913 = bb->region;
      D.22931 = bbn->region;
      if (D.22913 == D.22931) goto <D.23077>; else goto <D.23078>;
      <D.23077>:
      D.23011 = bbn->code;
      if (D.23011 != 0B) goto <D.23079>; else goto <D.23080>;
      <D.23079>:
      D.23011 = bbn->code;
      D.23014 = D.23011->opcode;
      if (D.23014 == 442) goto <D.23081>; else goto <D.23082>;
      <D.23081>:
      D.23011 = bbn->code;
      D.23017 = D.23011->data.op[0].target_block;
      D.23020 = D.23017->region;
      D.22913 = bb->region;
      if (D.23020 == D.22913) goto <D.23083>; else goto <D.23084>;
      <D.23083>:
      D.22934 = cfg->verbose_level;
      if (D.22934 > 2) goto <D.23085>; else goto <D.23086>;
      <D.23085>:
      D.22967 = bb->block_num;
      D.22937 = bbn->block_num;
      D.23011 = bbn->code;
      D.23017 = D.23011->data.op[0].target_block;
      D.23025 = D.23017->block_num;
      D.23011 = bbn->code;
      D.23014 = D.23011->opcode;
      D.23072 = (int) D.23014;
      monoeg_g_print ("cbranch2 to branch triggered %d -> (%d) %d (0x%02x)\n", D.22967, D.22937, D.23025, D.23072);
      <D.23086>:
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.22964 = *D.22963;
      mono_unlink_bblock (cfg, bb, D.22964);
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.23073 = D.22963 + 8;
      D.23074 = *D.23073;
      mono_unlink_bblock (cfg, bb, D.23074);
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.23073 = D.22963 + 8;
      D.23011 = bbn->code;
      D.23017 = D.23011->data.op[0].target_block;
      *D.23073 = D.23017;
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.22964 = *D.22963;
      mono_link_bblock (cfg, bb, D.22964);
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      D.23073 = D.22963 + 8;
      D.23074 = *D.23073;
      mono_link_bblock (cfg, bb, D.23074);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22379>;
      <D.23084>:
      <D.23082>:
      <D.23080>:
      <D.23078>:
      <D.23076>:
      D.22952 = bb->last_ins;
      D.22963 = D.22952->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.22963 + 8B];
      if (bbn != 0B) goto <D.23087>; else goto <D.23088>;
      <D.23087>:
      D.22913 = bb->region;
      D.22931 = bbn->region;
      if (D.22913 == D.22931) goto <D.23089>; else goto <D.23090>;
      <D.23089>:
      D.22925 = bbn->in_count;
      if (D.22925 == 1) goto <D.23091>; else goto <D.23092>;
      <D.23091>:
      D.23093 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.23094 = D.23093 & 268435456;
      if (D.23094 != 0) goto <D.23095>; else goto <D.23096>;
      <D.23095>:
      D.22928 = cfg->bb_exit;
      if (D.22928 != bbn) goto <D.23097>; else goto <D.23098>;
      <D.23097>:
      D.22916 = BIT_FIELD_REF <*bb, 64, 1472>;
      D.22986 = D.22916 & 17592186044416;
      if (D.22986 == 0) goto <D.23099>; else goto <D.23100>;
      <D.23099>:
      D.22978 = BIT_FIELD_REF <*bbn, 64, 1472>;
      D.22979 = D.22978 & 140737488355328;
      if (D.22979 == 0) goto <D.23101>; else goto <D.23102>;
      <D.23101>:
      D.23103 = mono_bblocks_linked (bbn, bb);
      if (D.23103 == 0) goto <D.23104>; else goto <D.23105>;
      <D.23104>:
      D.23106 = bbn->in_bb;
      D.23107 = *D.23106;
      D.23108 = D.23107 != bb;
      D.23109 = (long int) D.23108;
      D.23110 = __builtin_expect (D.23109, 0);
      if (D.23110 != 0) goto <D.23111>; else goto <D.23112>;
      <D.23111>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1432, "bbn->in_bb [0] == bb");
      <D.23112>:
      D.22934 = cfg->verbose_level;
      if (D.22934 > 2) goto <D.23113>; else goto <D.23114>;
      <D.23113>:
      D.22967 = bb->block_num;
      D.22937 = bbn->block_num;
      monoeg_g_print ("merge false branch target triggered BB%d -> BB%d\n", D.22967, D.22937);
      <D.23114>:
      mono_merge_basic_blocks (cfg, bb, bbn);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22379>;
      <D.23105>:
      <D.23102>:
      <D.23100>:
      <D.23098>:
      <D.23096>:
      <D.23092>:
      <D.23090>:
      <D.23088>:
    }
    <D.23030>:
    <D.23038>:
    <D.23032>:
    <D.23034>:
    D.22952 = bb->last_ins;
    if (D.22952 != 0B) goto <D.23119>; else goto <D.23120>;
    <D.23119>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22958 = D.22955 + 64985;
    if (D.22958 <= 9) goto <D.23117>; else goto <D.23121>;
    <D.23121>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22960 = D.22955 + 64878;
    if (D.22960 <= 9) goto <D.23117>; else goto <D.23122>;
    <D.23122>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22962 = D.22955 + 64888;
    if (D.22962 <= 9) goto <D.23117>; else goto <D.23118>;
    <D.23117>:
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.22960 = D.22955 + 64878;
    if (D.22960 > 9) goto <D.23123>; else goto <D.23124>;
    <D.23123>:
    D.22952 = bb->last_ins;
    D.23039 = D.22952->data.op[0].src;
    if (D.23039 == 0B) goto <D.23115>; else goto <D.23125>;
    <D.23125>:
    D.22952 = bb->last_ins;
    D.23039 = D.22952->data.op[0].src;
    D.23041 = D.23039->data.op[0].src;
    D.23042 = D.23041->type;
    if (D.23042 != 4) goto <D.23115>; else goto <D.23116>;
    <D.23115>:
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    D.23073 = D.22963 + 8;
    D.23074 = *D.23073;
    if (D.23074 != 0B) goto <D.23126>; else goto <D.23127>;
    <D.23126>:
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    D.23073 = D.22963 + 8;
    D.23074 = *D.23073;
    D.23128 = BIT_FIELD_REF <*D.23074, 64, 1472>;
    D.23129 = D.23128 & 140737488355328;
    if (D.23129 != 0) goto <D.23130>; else goto <D.23131>;
    <D.23130>:
    D.22913 = bb->region;
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    D.23073 = D.22963 + 8;
    D.23074 = *D.23073;
    D.23132 = D.23074->region;
    if (D.22913 == D.23132) goto <D.23133>; else goto <D.23134>;
    <D.23133>:
    D.23093 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.23135 = D.23093 & 128;
    if (D.23135 == 0) goto <D.23136>; else goto <D.23137>;
    <D.23136>:
    D.22952 = bb->last_ins;
    D.22952 = bb->last_ins;
    D.22955 = D.22952->opcode;
    D.23138 = (unsigned int) D.22955;
    D.23139 = mono_reverse_branch_op (D.23138);
    D.23140 = (short unsigned int) D.23139;
    D.22952->opcode = D.23140;
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    bbn = MEM[(struct MonoBasicBlock * *)D.22963 + 8B];
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    D.23073 = D.22963 + 8;
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    D.22964 = *D.22963;
    *D.23073 = D.22964;
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    *D.22963 = bbn;
    D.22952 = bb->last_ins;
    D.22963 = D.22952->data.op[1].many_blocks;
    D.22964 = *D.22963;
    move_basic_block_to_end (cfg, D.22964);
    D.22934 = cfg->verbose_level;
    if (D.22934 > 2) goto <D.23141>; else goto <D.23142>;
    <D.23141>:
    D.22967 = bb->block_num;
    monoeg_g_print ("cbranch to throw block triggered %d.\n", D.22967);
    <D.23142>:
    <D.23137>:
    <D.23134>:
    <D.23131>:
    <D.23127>:
    <D.23116>:
    <D.23124>:
    <D.23118>:
    <D.23120>:
    <D.23028>:
    <D.23026>:
    <D.22379>:
    previous_bb = bb;
    bb = bb->next_bb;
    <D.22390>:
    if (bb != 0B) goto <D.22389>; else goto <D.22391>;
    <D.22391>:
  }
  if (changed != 0) goto <D.23143>; else goto <D.22393>;
  <D.23143>:
  if (niterations != 0) goto <D.22392>; else goto <D.22393>;
  <D.22393>:
}


remove_block_if_useless (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * previous_bb)
{
  unsigned int D.23144;
  gboolean D.23147;
  short unsigned int D.23148;
  int D.23149;
  short int D.23154;
  struct MonoBasicBlock * * D.23156;
  struct MonoBasicBlock * D.23157;
  struct MonoBasicBlock * D.23158;
  struct MonoInst * D.23160;
  short unsigned int D.23163;
  struct MonoBasicBlock * D.23166;
  unsigned int D.23171;
  unsigned int D.23172;
  unsigned int D.23178;
  int D.23181;
  struct MonoBasicBlock * * D.23182;
  short int D.23183;
  int D.23186;
  struct MonoBasicBlock * * D.23189;
  long unsigned int D.23190;
  long unsigned int D.23191;
  struct MonoBasicBlock * * D.23192;
  struct MonoBasicBlock * D.23193;
  struct MonoMemPool * D.23196;
  int D.23197;
  int D.23198;
  const unsigned char * D.23199;
  unsigned char * D.23203;
  short int D.23204;
  int D.23205;
  struct MonoBasicBlock * target_bb;
  struct MonoInst * inst;

  target_bb = 0B;
  D.23144 = bb->region;
  if (D.23144 != 4294967295) goto <D.23145>; else goto <D.23146>;
  <D.23145>:
  bb->not_useless = 1;
  D.23147 = 0;
  return D.23147;
  <D.23146>:
  inst = bb->code;
  goto <D.22269>;
  <D.22268>:
  D.23148 = inst->opcode;
  D.23149 = (int) D.23148;
  switch (D.23149) <default: <D.22267>, case 316: <D.22264>, case 442: <D.22266>>
  <D.22264>:
  goto <D.22265>;
  <D.22266>:
  target_bb = inst->data.op[0].target_block;
  goto <D.22265>;
  <D.22267>:
  bb->not_useless = 1;
  D.23147 = 0;
  return D.23147;
  <D.22265>:
  inst = inst->next;
  <D.22269>:
  if (inst != 0B) goto <D.22268>; else goto <D.22270>;
  <D.22270>:
  if (target_bb == 0B) goto <D.23150>; else goto <D.23151>;
  <D.23150>:
  D.23154 = bb->out_count;
  if (D.23154 == 1) goto <D.23155>; else goto <D.23152>;
  <D.23155>:
  D.23156 = bb->out_bb;
  D.23157 = *D.23156;
  D.23158 = bb->next_bb;
  if (D.23157 == D.23158) goto <D.23159>; else goto <D.23152>;
  <D.23159>:
  target_bb = bb->next_bb;
  goto <D.23153>;
  <D.23152>:
  D.23147 = 0;
  return D.23147;
  <D.23153>:
  <D.23151>:
  D.23160 = previous_bb->last_ins;
  if (D.23160 != 0B) goto <D.23161>; else goto <D.23162>;
  <D.23161>:
  D.23160 = previous_bb->last_ins;
  D.23163 = D.23160->opcode;
  if (D.23163 == 370) goto <D.23164>; else goto <D.23165>;
  <D.23164>:
  D.23147 = 0;
  return D.23147;
  <D.23165>:
  <D.23162>:
  D.23166 = cfg->bb_entry;
  if (D.23166 == previous_bb) goto <D.23167>; else goto <D.23168>;
  <D.23167>:
  D.23158 = bb->next_bb;
  if (D.23158 != target_bb) goto <D.23169>; else goto <D.23170>;
  <D.23169>:
  D.23147 = 0;
  return D.23147;
  <D.23170>:
  <D.23168>:
  D.23171 = previous_bb->region;
  D.23172 = D.23171 & 240;
  if (D.23172 == 0) goto <D.23173>; else goto <D.23174>;
  <D.23173>:
  D.23147 = 0;
  return D.23147;
  <D.23174>:
  if (target_bb != 0B) goto <D.23176>; else goto <D.23175>;
  <D.23176>:
  if (target_bb != bb) goto <D.23177>; else goto <D.23175>;
  <D.23177>:
  {
    int i;

    D.23178 = cfg->verbose_level;
    if (D.23178 > 1) goto <D.23179>; else goto <D.23180>;
    <D.23179>:
    D.23181 = bb->block_num;
    printf ("remove_block_if_useless, removed BB%d\n", D.23181);
    <D.23180>:
    goto <D.22274>;
    <D.22273>:
    {
      struct MonoBasicBlock * in_bb;

      D.23182 = bb->in_bb;
      in_bb = *D.23182;
      mono_unlink_bblock (cfg, in_bb, bb);
      mono_link_bblock (cfg, in_bb, target_bb);
      replace_out_block_in_code (in_bb, bb, target_bb);
    }
    <D.22274>:
    D.23183 = bb->in_count;
    if (D.23183 != 0) goto <D.22273>; else goto <D.22275>;
    <D.22275>:
    mono_unlink_bblock (cfg, bb, target_bb);
    D.23166 = cfg->bb_entry;
    if (D.23166 != previous_bb) goto <D.23184>; else goto <D.23185>;
    <D.23184>:
    D.23186 = mono_bb_is_fall_through (cfg, previous_bb);
    if (D.23186 != 0) goto <D.23187>; else goto <D.23188>;
    <D.23187>:
    i = 0;
    goto <D.22279>;
    <D.22278>:
    D.23189 = previous_bb->out_bb;
    D.23190 = (long unsigned int) i;
    D.23191 = D.23190 * 8;
    D.23192 = D.23189 + D.23191;
    D.23193 = *D.23192;
    if (D.23193 == target_bb) goto <D.23194>; else goto <D.23195>;
    <D.23194>:
    {
      struct MonoInst * jump;

      D.23196 = cfg->mempool;
      jump = mono_mempool_alloc0 (D.23196, 80);
      jump->opcode = 442;
      jump->dreg = -1;
      jump->sreg3 = -1;
      D.23197 = jump->sreg3;
      jump->sreg2 = D.23197;
      D.23198 = jump->sreg2;
      jump->sreg1 = D.23198;
      D.23199 = cfg->ip;
      jump->cil_code = D.23199;
      D.23160 = previous_bb->last_ins;
      if (D.23160 != 0B) goto <D.23200>; else goto <D.23201>;
      <D.23200>:
      D.23160 = previous_bb->last_ins;
      D.23160->next = jump;
      D.23160 = previous_bb->last_ins;
      jump->prev = D.23160;
      previous_bb->last_ins = jump;
      goto <D.23202>;
      <D.23201>:
      previous_bb->last_ins = jump;
      D.23160 = previous_bb->last_ins;
      previous_bb->code = D.23160;
      <D.23202>:
      D.23203 = previous_bb->cil_code;
      jump->cil_code = D.23203;
      jump->data.op[0].target_block = target_bb;
      goto <D.22277>;
    }
    <D.23195>:
    i = i + 1;
    <D.22279>:
    D.23204 = previous_bb->out_count;
    D.23205 = (int) D.23204;
    if (D.23205 > i) goto <D.22278>; else goto <D.22277>;
    <D.22277>:
    <D.23188>:
    <D.23185>:
    D.23158 = bb->next_bb;
    previous_bb->next_bb = D.23158;
    mono_nullify_basic_block (bb);
    D.23147 = 1;
    return D.23147;
  }
  <D.23175>:
  D.23147 = 0;
  return D.23147;
}


move_basic_block_to_end (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.23208;
  struct MonoBasicBlock * D.23212;
  struct MonoInst * D.23217;
  short unsigned int D.23219;
  short unsigned int D.23223;
  short unsigned int D.23225;
  short unsigned int D.23227;
  struct MonoMemPool * D.23228;
  int D.23229;
  int D.23230;
  const unsigned char * D.23231;
  struct MonoBasicBlock * bbn;
  struct MonoBasicBlock * next;

  next = bb->next_bb;
  bbn = cfg->bb_entry;
  goto <D.22315>;
  <D.22314>:
  bbn = bbn->next_bb;
  <D.22315>:
  D.23208 = bbn->next_bb;
  if (D.23208 != 0B) goto <D.23209>; else goto <D.22316>;
  <D.23209>:
  D.23208 = bbn->next_bb;
  if (D.23208 != bb) goto <D.22314>; else goto <D.22316>;
  <D.22316>:
  D.23208 = bbn->next_bb;
  if (D.23208 != 0B) goto <D.23210>; else goto <D.23211>;
  <D.23210>:
  D.23212 = bb->next_bb;
  bbn->next_bb = D.23212;
  <D.23211>:
  bbn = cfg->bb_entry;
  goto <D.22318>;
  <D.22317>:
  bbn = bbn->next_bb;
  <D.22318>:
  D.23208 = bbn->next_bb;
  if (D.23208 != 0B) goto <D.22317>; else goto <D.22319>;
  <D.22319>:
  bbn->next_bb = bb;
  bb->next_bb = 0B;
  if (next != 0B) goto <D.23215>; else goto <D.23216>;
  <D.23215>:
  D.23217 = bb->last_ins;
  if (D.23217 == 0B) goto <D.23213>; else goto <D.23218>;
  <D.23218>:
  D.23217 = bb->last_ins;
  D.23219 = D.23217->opcode;
  if (D.23219 != 798) goto <D.23220>; else goto <D.23214>;
  <D.23220>:
  D.23217 = bb->last_ins;
  D.23219 = D.23217->opcode;
  if (D.23219 != 442) goto <D.23221>; else goto <D.23214>;
  <D.23221>:
  D.23217 = bb->last_ins;
  D.23219 = D.23217->opcode;
  if (D.23219 != 759) goto <D.23222>; else goto <D.23214>;
  <D.23222>:
  D.23217 = bb->last_ins;
  D.23219 = D.23217->opcode;
  D.23223 = D.23219 + 64985;
  if (D.23223 > 9) goto <D.23224>; else goto <D.23214>;
  <D.23224>:
  D.23217 = bb->last_ins;
  D.23219 = D.23217->opcode;
  D.23225 = D.23219 + 64878;
  if (D.23225 > 9) goto <D.23226>; else goto <D.23214>;
  <D.23226>:
  D.23217 = bb->last_ins;
  D.23219 = D.23217->opcode;
  D.23227 = D.23219 + 64888;
  if (D.23227 > 9) goto <D.23213>; else goto <D.23214>;
  <D.23213>:
  {
    struct MonoInst * ins;

    D.23228 = cfg->mempool;
    ins = mono_mempool_alloc0 (D.23228, 80);
    ins->opcode = 442;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.23229 = ins->sreg3;
    ins->sreg2 = D.23229;
    D.23230 = ins->sreg2;
    ins->sreg1 = D.23230;
    D.23231 = cfg->ip;
    ins->cil_code = D.23231;
    D.23217 = bb->last_ins;
    if (D.23217 != 0B) goto <D.23232>; else goto <D.23233>;
    <D.23232>:
    D.23217 = bb->last_ins;
    D.23217->next = ins;
    D.23217 = bb->last_ins;
    ins->prev = D.23217;
    bb->last_ins = ins;
    goto <D.23234>;
    <D.23233>:
    bb->last_ins = ins;
    D.23217 = bb->last_ins;
    bb->code = D.23217;
    <D.23234>:
    mono_link_bblock (cfg, bb, next);
    ins->data.op[0].target_block = next;
  }
  <D.23214>:
  <D.23216>:
}