mono_local_alias_analysis (struct MonoCompile * cfg)
{
  unsigned char D.24429;
  unsigned char D.24430;
  unsigned int D.24433;
  int D.24436;
  unsigned int D.24438;
  unsigned int D.24439;
  int D.24442;
  void done = <<< error >>>;

  D.24429 = BIT_FIELD_REF <*cfg, 8, 3432>;
  D.24430 = D.24429 & 4;
  if (D.24430 == 0) goto <D.24431>; else goto <D.24432>;
  <D.24431>:
  return;
  <D.24432>:
  D.24433 = cfg->verbose_level;
  if (D.24433 > 2) goto <D.24434>; else goto <D.24435>;
  <D.24434>:
  mono_print_code (cfg, "BEFORE ALIAS_ANALYSIS");
  <D.24435>:
  D.24436 = lower_memory_access (cfg);
  if (D.24436 == 0) goto done; else goto <D.24437>;
  <D.24437>:
  D.24438 = cfg->opt;
  D.24439 = D.24438 & 64;
  if (D.24439 != 0) goto <D.24440>; else goto <D.24441>;
  <D.24440>:
  mono_local_deadce (cfg);
  <D.24441>:
  D.24442 = recompute_aliased_variables (cfg);
  if (D.24442 == 0) goto done; else goto <D.24443>;
  <D.24443>:
  mono_handle_global_vregs (cfg);
  D.24438 = cfg->opt;
  D.24439 = D.24438 & 64;
  if (D.24439 != 0) goto <D.24444>; else goto <D.24445>;
  <D.24444>:
  mono_local_deadce (cfg);
  <D.24445>:
  done:
  D.24433 = cfg->verbose_level;
  if (D.24433 > 2) goto <D.24446>; else goto <D.24447>;
  <D.24446>:
  mono_print_code (cfg, "AFTER ALIAS_ANALYSIS");
  <D.24447>:
}


lower_memory_access (struct MonoCompile * cfg)
{
  short unsigned int D.24449;
  int D.24450;
  int D.24451;
  void * D.24452;
  unsigned int D.24453;
  int D.24456;
  const void * D.24457;
  const void * D.24463;
  int D.24464;
  int D.24469;
  int D.24476;
  int D.24483;
  int D.24490;
  gboolean D.24492;
  struct MonoBasicBlock * bb;
  struct MonoInst * ins;
  struct MonoInst * tmp;
  gboolean needs_dce;
  struct GHashTable * addr_loads;

  needs_dce = 0;
  addr_loads = monoeg_g_hash_table_new (0B, 0B);
  bb = cfg->bb_entry;
  goto <D.24401>;
  <D.24400>:
  monoeg_g_hash_table_remove_all (addr_loads);
  ins = bb->code;
  goto <D.24398>;
  <D.24397>:
  D.24449 = ins->opcode;
  D.24450 = (int) D.24449;
  switch (D.24450) <default: <D.24491>, case 314: <D.24371>, case 374: <D.24386>, case 375: <D.24387>, case 376: <D.24388>, case 377: <D.24389>, case 378: <D.24390>, case 379: <D.24391>, case 380: <D.24392>, case 381: <D.24394>, case 384: <D.24395>, case 385: <D.24396>, case 387: <D.24393>, case 388: <D.24375>, case 389: <D.24381>, case 390: <D.24376>, case 391: <D.24377>, case 392: <D.24378>, case 393: <D.24379>, case 394: <D.24380>, case 395: <D.24382>, case 396: <D.24383>, case 397: <D.24384>, case 399: <D.24374>, case 424: <D.24373>>
  <D.24371>:
  D.24451 = ins->dreg;
  D.24452 = (void *) D.24451;
  monoeg_g_hash_table_insert_replace (addr_loads, D.24452, ins, 0);
  D.24453 = cfg->verbose_level;
  if (D.24453 > 2) goto <D.24454>; else goto <D.24455>;
  <D.24454>:
  printf ("New address: ");
  mono_print_ins (ins);
  <D.24455>:
  goto <D.24372>;
  <D.24373>:
  D.24456 = ins->sreg1;
  D.24457 = (const void *) D.24456;
  tmp = monoeg_g_hash_table_lookup (addr_loads, D.24457);
  if (tmp != 0B) goto <D.24458>; else goto <D.24459>;
  <D.24458>:
  D.24451 = ins->dreg;
  D.24452 = (void *) D.24451;
  monoeg_g_hash_table_insert_replace (addr_loads, D.24452, tmp, 0);
  D.24453 = cfg->verbose_level;
  if (D.24453 > 2) goto <D.24460>; else goto <D.24461>;
  <D.24460>:
  printf ("New alias: ");
  mono_print_ins (ins);
  <D.24461>:
  goto <D.24462>;
  <D.24459>:
  D.24451 = ins->dreg;
  D.24463 = (const void *) D.24451;
  D.24464 = monoeg_g_hash_table_remove (addr_loads, D.24463);
  if (D.24464 != 0) goto <D.24465>; else goto <D.24466>;
  <D.24465>:
  D.24453 = cfg->verbose_level;
  if (D.24453 > 2) goto <D.24467>; else goto <D.24468>;
  <D.24467>:
  printf ("Killed alias: ");
  mono_print_ins (ins);
  <D.24468>:
  <D.24466>:
  <D.24462>:
  goto <D.24372>;
  <D.24374>:
  <D.24375>:
  <D.24376>:
  <D.24377>:
  <D.24378>:
  <D.24379>:
  <D.24380>:
  <D.24381>:
  <D.24382>:
  <D.24383>:
  <D.24384>:
  D.24469 = ins->data.op[0].const_val;
  if (D.24469 != 0) goto <D.24470>; else goto <D.24471>;
  <D.24470>:
  // predicted unlikely by continue predictor.
  goto <D.24385>;
  <D.24471>:
  D.24456 = ins->sreg1;
  D.24457 = (const void *) D.24456;
  tmp = monoeg_g_hash_table_lookup (addr_loads, D.24457);
  if (tmp != 0B) goto <D.24472>; else goto <D.24473>;
  <D.24472>:
  D.24453 = cfg->verbose_level;
  if (D.24453 > 2) goto <D.24474>; else goto <D.24475>;
  <D.24474>:
  printf ("Found candidate load:");
  mono_print_ins (ins);
  <D.24475>:
  D.24476 = lower_load (cfg, ins, tmp);
  needs_dce = D.24476 | needs_dce;
  <D.24473>:
  goto <D.24372>;
  <D.24386>:
  <D.24387>:
  <D.24388>:
  <D.24389>:
  <D.24390>:
  <D.24391>:
  <D.24392>:
  <D.24393>:
  D.24469 = ins->data.op[0].const_val;
  if (D.24469 != 0) goto <D.24477>; else goto <D.24478>;
  <D.24477>:
  // predicted unlikely by continue predictor.
  goto <D.24385>;
  <D.24478>:
  D.24451 = ins->dreg;
  D.24463 = (const void *) D.24451;
  tmp = monoeg_g_hash_table_lookup (addr_loads, D.24463);
  if (tmp != 0B) goto <D.24479>; else goto <D.24480>;
  <D.24479>:
  D.24453 = cfg->verbose_level;
  if (D.24453 > 2) goto <D.24481>; else goto <D.24482>;
  <D.24481>:
  printf ("Found candidate store:");
  mono_print_ins (ins);
  <D.24482>:
  D.24483 = lower_store (cfg, ins, tmp);
  needs_dce = D.24483 | needs_dce;
  <D.24480>:
  goto <D.24372>;
  <D.24394>:
  <D.24395>:
  <D.24396>:
  D.24469 = ins->data.op[0].const_val;
  if (D.24469 != 0) goto <D.24484>; else goto <D.24485>;
  <D.24484>:
  // predicted unlikely by continue predictor.
  goto <D.24385>;
  <D.24485>:
  D.24451 = ins->dreg;
  D.24463 = (const void *) D.24451;
  tmp = monoeg_g_hash_table_lookup (addr_loads, D.24463);
  if (tmp != 0B) goto <D.24486>; else goto <D.24487>;
  <D.24486>:
  D.24453 = cfg->verbose_level;
  if (D.24453 > 2) goto <D.24488>; else goto <D.24489>;
  <D.24488>:
  printf ("Found candidate store-imm:");
  mono_print_ins (ins);
  <D.24489>:
  D.24490 = lower_store_imm (cfg, ins, tmp);
  needs_dce = D.24490 | needs_dce;
  <D.24487>:
  goto <D.24372>;
  <D.24491>:
  <D.24372>:
  <D.24385>:
  ins = ins->next;
  <D.24398>:
  if (ins != 0B) goto <D.24397>; else goto <D.24399>;
  <D.24399>:
  bb = bb->next_bb;
  <D.24401>:
  if (bb != 0B) goto <D.24400>; else goto <D.24402>;
  <D.24402>:
  monoeg_g_hash_table_destroy (addr_loads);
  D.24492 = needs_dce;
  return D.24492;
}


lower_load (struct MonoCompile * cfg, struct MonoInst * load, struct MonoInst * ldaddr)
{
  struct MonoClass * D.24494;
  unsigned int D.24495;
  short unsigned int D.24496;
  struct MonoClass * D.24499;
  unsigned int D.24502;
  const char * D.24505;
  const char * D.24506;
  gboolean D.24507;
  int D.24508;
  const char * D.24513;
  const char * D.24514;
  unsigned int D.24517;
  short unsigned int D.24518;
  int D.24519;
  int D.24520;
  int D.24521;
  struct MonoInst * var;
  struct MonoType * type;
  int replaced_op;

  var = ldaddr->data.op[0].p;
  D.24494 = var->klass;
  type = &D.24494->byval_arg;
  D.24495 = mono_type_to_load_membase (cfg, type);
  replaced_op = (int) D.24495;
  D.24496 = load->opcode;
  if (D.24496 == 399) goto <D.24497>; else goto <D.24498>;
  <D.24497>:
  D.24499 = load->klass;
  D.24494 = var->klass;
  if (D.24499 != D.24494) goto <D.24500>; else goto <D.24501>;
  <D.24500>:
  D.24502 = cfg->verbose_level;
  if (D.24502 > 2) goto <D.24503>; else goto <D.24504>;
  <D.24503>:
  D.24499 = load->klass;
  D.24505 = D.24499->name;
  D.24494 = var->klass;
  D.24506 = D.24494->name;
  printf ("Incompatible load_vtype classes %s x %s\n", D.24505, D.24506);
  <D.24504>:
  D.24507 = 0;
  return D.24507;
  <D.24501>:
  <D.24498>:
  D.24496 = load->opcode;
  D.24508 = (int) D.24496;
  if (D.24508 != replaced_op) goto <D.24509>; else goto <D.24510>;
  <D.24509>:
  D.24502 = cfg->verbose_level;
  if (D.24502 > 2) goto <D.24511>; else goto <D.24512>;
  <D.24511>:
  D.24513 = mono_inst_name (replaced_op);
  D.24496 = load->opcode;
  D.24508 = (int) D.24496;
  D.24514 = mono_inst_name (D.24508);
  printf ("Incompatible load type: expected %s but got %s\n", D.24513, D.24514);
  <D.24512>:
  D.24507 = 0;
  return D.24507;
  <D.24510>:
  D.24502 = cfg->verbose_level;
  if (D.24502 > 2) goto <D.24515>; else goto <D.24516>;
  <D.24515>:
  printf ("mem2reg replacing: ");
  mono_print_ins (load);
  <D.24516>:
  D.24517 = mono_type_to_regmove (cfg, type);
  D.24518 = (short unsigned int) D.24517;
  load->opcode = D.24518;
  type_to_eval_stack_type (cfg, type, load);
  D.24519 = var->dreg;
  load->sreg1 = D.24519;
  D.24520 = mono_jit_stats.loads_eliminated;
  D.24521 = D.24520 + 1;
  mono_jit_stats.loads_eliminated = D.24521;
  D.24507 = 1;
  return D.24507;
}


lower_store (struct MonoCompile * cfg, struct MonoInst * store, struct MonoInst * ldaddr)
{
  struct MonoClass * D.24523;
  unsigned int D.24524;
  short unsigned int D.24525;
  struct MonoClass * D.24528;
  unsigned int D.24531;
  const char * D.24534;
  gboolean D.24535;
  int D.24536;
  const char * D.24541;
  const char * D.24542;
  unsigned int D.24545;
  short unsigned int D.24546;
  int D.24547;
  int D.24548;
  int D.24549;
  struct MonoInst * var;
  struct MonoType * type;
  int replaced_op;

  var = ldaddr->data.op[0].p;
  D.24523 = var->klass;
  type = &D.24523->byval_arg;
  D.24524 = mono_type_to_store_membase (cfg, type);
  replaced_op = (int) D.24524;
  D.24525 = store->opcode;
  if (D.24525 == 387) goto <D.24526>; else goto <D.24527>;
  <D.24526>:
  D.24528 = store->klass;
  D.24523 = var->klass;
  if (D.24528 != D.24523) goto <D.24529>; else goto <D.24530>;
  <D.24529>:
  D.24531 = cfg->verbose_level;
  if (D.24531 > 2) goto <D.24532>; else goto <D.24533>;
  <D.24532>:
  D.24528 = store->klass;
  D.24534 = D.24528->name;
  D.24528 = store->klass;
  D.24534 = D.24528->name;
  printf ("Incompatible store_vtype classes %s x %s\n", D.24534, D.24534);
  <D.24533>:
  D.24535 = 0;
  return D.24535;
  <D.24530>:
  <D.24527>:
  D.24525 = store->opcode;
  D.24536 = (int) D.24525;
  if (D.24536 != replaced_op) goto <D.24537>; else goto <D.24538>;
  <D.24537>:
  D.24531 = cfg->verbose_level;
  if (D.24531 > 2) goto <D.24539>; else goto <D.24540>;
  <D.24539>:
  D.24541 = mono_inst_name (replaced_op);
  D.24525 = store->opcode;
  D.24536 = (int) D.24525;
  D.24542 = mono_inst_name (D.24536);
  printf ("Incompatible store_reg type: expected %s but got %s\n", D.24541, D.24542);
  <D.24540>:
  D.24535 = 0;
  return D.24535;
  <D.24538>:
  D.24531 = cfg->verbose_level;
  if (D.24531 > 2) goto <D.24543>; else goto <D.24544>;
  <D.24543>:
  printf ("mem2reg replacing: ");
  mono_print_ins (store);
  <D.24544>:
  D.24545 = mono_type_to_regmove (cfg, type);
  D.24546 = (short unsigned int) D.24545;
  store->opcode = D.24546;
  type_to_eval_stack_type (cfg, type, store);
  D.24547 = var->dreg;
  store->dreg = D.24547;
  D.24548 = mono_jit_stats.stores_eliminated;
  D.24549 = D.24548 + 1;
  mono_jit_stats.stores_eliminated = D.24549;
  D.24535 = 1;
  return D.24535;
}


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

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


lower_store_imm (struct MonoCompile * cfg, struct MonoInst * store, struct MonoInst * ldaddr)
{
  struct MonoClass * D.24553;
  unsigned int D.24554;
  unsigned int store_op.0;
  unsigned int D.24556;
  gboolean D.24559;
  short unsigned int D.24560;
  int D.24561;
  unsigned char D.24562;
  int D.24563;
  int D.24564;
  unsigned int D.24567;
  int D.24572;
  int D.24573;
  int D.24574;
  long long int D.24581;
  int D.24582;
  int D.24583;
  struct MonoInst * var;
  struct MonoType * type;
  int store_op;

  var = ldaddr->data.op[0].p;
  D.24553 = var->klass;
  type = &D.24553->byval_arg;
  D.24554 = mono_type_to_store_membase (cfg, type);
  store_op = (int) D.24554;
  store_op.0 = (unsigned int) store_op;
  D.24556 = store_op.0 + 4294966910;
  if (D.24556 <= 1) goto <D.24557>; else goto <D.24558>;
  <D.24557>:
  D.24559 = 0;
  return D.24559;
  <D.24558>:
  D.24560 = store->opcode;
  D.24561 = (int) D.24560;
  switch (D.24561) <default: <D.24362>, case 381: <D.24358>, case 384: <D.24359>, case 385: <D.24361>>
  <D.24358>:
  <D.24359>:
  D.24562 = var->type;
  D.24563 = (int) D.24562;
  D.24564 = is_int_stack_size (D.24563);
  if (D.24564 == 0) goto <D.24565>; else goto <D.24566>;
  <D.24565>:
  D.24567 = cfg->verbose_level;
  if (D.24567 > 2) goto <D.24568>; else goto <D.24569>;
  <D.24568>:
  printf ("Incompatible variable of size != 4\n");
  <D.24569>:
  D.24559 = 0;
  return D.24559;
  <D.24566>:
  D.24567 = cfg->verbose_level;
  if (D.24567 > 2) goto <D.24570>; else goto <D.24571>;
  <D.24570>:
  printf ("mem2reg replacing: ");
  mono_print_ins (store);
  <D.24571>:
  store->opcode = 362;
  store->type = 1;
  D.24572 = var->dreg;
  store->dreg = D.24572;
  D.24573 = store->data.op[1].const_val;
  store->data.op[0].const_val = D.24573;
  goto <D.24360>;
  <D.24361>:
  D.24562 = var->type;
  D.24563 = (int) D.24562;
  D.24574 = is_long_stack_size (D.24563);
  if (D.24574 == 0) goto <D.24575>; else goto <D.24576>;
  <D.24575>:
  D.24567 = cfg->verbose_level;
  if (D.24567 > 2) goto <D.24577>; else goto <D.24578>;
  <D.24577>:
  printf ("Incompatible variable of size != 8\n");
  <D.24578>:
  D.24559 = 0;
  return D.24559;
  <D.24576>:
  D.24567 = cfg->verbose_level;
  if (D.24567 > 2) goto <D.24579>; else goto <D.24580>;
  <D.24579>:
  printf ("mem2reg replacing: ");
  mono_print_ins (store);
  <D.24580>:
  store->opcode = 363;
  store->type = 2;
  D.24572 = var->dreg;
  store->dreg = D.24572;
  D.24573 = store->data.op[1].const_val;
  D.24581 = (long long int) D.24573;
  store->data.i8const = D.24581;
  goto <D.24360>;
  <D.24362>:
  D.24559 = 0;
  return D.24559;
  <D.24360>:
  D.24582 = mono_jit_stats.stores_eliminated;
  D.24583 = D.24582 + 1;
  mono_jit_stats.stores_eliminated = D.24583;
  D.24559 = 1;
  return D.24559;
}


is_int_stack_size (int type)
{
  gboolean D.24585;
  _Bool D.24586;
  _Bool D.24587;
  _Bool D.24588;

  D.24586 = type == 1;
  D.24587 = type == 5;
  D.24588 = D.24586 | D.24587;
  D.24585 = (gboolean) D.24588;
  return D.24585;
}


is_long_stack_size (int type)
{
  gboolean D.24590;
  _Bool D.24591;

  D.24591 = type == 2;
  D.24590 = (gboolean) D.24591;
  return D.24590;
}


recompute_aliased_variables (struct MonoCompile * cfg)
{
  struct MonoInst * * D.24593;
  unsigned int i.1;
  unsigned int D.24595;
  struct MonoInst * * D.24596;
  unsigned char D.24597;
  int D.24598;
  int D.24599;
  unsigned int D.24602;
  unsigned char D.24605;
  unsigned int i.2;
  unsigned int D.24607;
  gboolean D.24610;
  short unsigned int D.24611;
  unsigned char D.24616;
  int D.24617;
  int D.24618;
  unsigned char D.24623;
  int D.24624;
  int D.24625;
  int D.24626;
  int D.24627;
  int D.24628;
  struct MonoMethod * D.24633;
  char * D.24634;
  int i;
  struct MonoBasicBlock * bb;
  struct MonoInst * ins;
  int kills;
  int adds;

  kills = 0;
  adds = 0;
  i = 0;
  goto <D.24413>;
  <D.24412>:
  {
    struct MonoInst * var;

    D.24593 = cfg->varinfo;
    i.1 = (unsigned int) i;
    D.24595 = i.1 * 4;
    D.24596 = D.24593 + D.24595;
    var = *D.24596;
    D.24597 = var->flags;
    D.24598 = (int) D.24597;
    D.24599 = D.24598 & 16;
    if (D.24599 != 0) goto <D.24600>; else goto <D.24601>;
    <D.24600>:
    D.24602 = cfg->verbose_level;
    if (D.24602 > 2) goto <D.24603>; else goto <D.24604>;
    <D.24603>:
    printf ("Killing :");
    mono_print_ins (var);
    <D.24604>:
    kills = kills + 1;
    <D.24601>:
    D.24597 = var->flags;
    D.24605 = D.24597 & 239;
    var->flags = D.24605;
  }
  i = i + 1;
  <D.24413>:
  i.2 = (unsigned int) i;
  D.24607 = cfg->num_varinfo;
  if (i.2 < D.24607) goto <D.24412>; else goto <D.24414>;
  <D.24414>:
  if (kills == 0) goto <D.24608>; else goto <D.24609>;
  <D.24608>:
  D.24610 = 0;
  return D.24610;
  <D.24609>:
  bb = cfg->bb_entry;
  goto <D.24420>;
  <D.24419>:
  ins = bb->code;
  goto <D.24417>;
  <D.24416>:
  D.24611 = ins->opcode;
  if (D.24611 == 314) goto <D.24612>; else goto <D.24613>;
  <D.24612>:
  {
    struct MonoInst * var;

    D.24602 = cfg->verbose_level;
    if (D.24602 > 2) goto <D.24614>; else goto <D.24615>;
    <D.24614>:
    printf ("Found op :");
    mono_print_ins (ins);
    <D.24615>:
    var = ins->data.op[0].p;
    D.24616 = var->flags;
    D.24617 = (int) D.24616;
    D.24618 = D.24617 & 16;
    if (D.24618 == 0) goto <D.24619>; else goto <D.24620>;
    <D.24619>:
    D.24602 = cfg->verbose_level;
    if (D.24602 != 0) goto <D.24621>; else goto <D.24622>;
    <D.24621>:
    printf ("Restoring :");
    mono_print_ins (var);
    <D.24622>:
    adds = adds + 1;
    <D.24620>:
    D.24616 = var->flags;
    D.24623 = D.24616 | 16;
    var->flags = D.24623;
  }
  <D.24613>:
  ins = ins->next;
  <D.24417>:
  if (ins != 0B) goto <D.24416>; else goto <D.24418>;
  <D.24418>:
  bb = bb->next_bb;
  <D.24420>:
  if (bb != 0B) goto <D.24419>; else goto <D.24421>;
  <D.24421>:
  D.24624 = mono_jit_stats.alias_found;
  D.24625 = D.24624 + kills;
  mono_jit_stats.alias_found = D.24625;
  D.24626 = mono_jit_stats.alias_removed;
  D.24627 = kills - adds;
  D.24628 = D.24626 + D.24627;
  mono_jit_stats.alias_removed = D.24628;
  if (kills > adds) goto <D.24629>; else goto <D.24630>;
  <D.24629>:
  D.24602 = cfg->verbose_level;
  if (D.24602 > 2) goto <D.24631>; else goto <D.24632>;
  <D.24631>:
  D.24633 = cfg->method;
  D.24634 = mono_method_full_name (D.24633, 1);
  printf ("Method: %s\n", D.24634);
  printf ("Kills %d Adds %d\n", kills, adds);
  <D.24632>:
  D.24610 = 1;
  return D.24610;
  <D.24630>:
  D.24610 = 0;
  return D.24610;
}