mono_debug_init_method (struct MonoCompile * cfg, struct MonoBasicBlock * start_block, guint32 breakpoint_id)
{
  int D.22370;
  struct MiniDebugMethodInfo * info;

  D.22370 = mono_debug_enabled ();
  if (D.22370 == 0) goto <D.22371>; else goto <D.22372>;
  <D.22371>:
  return;
  <D.22372>:
  info = monoeg_malloc0 (16);
  info->breakpoint_id = breakpoint_id;
  cfg->debug_info = info;
}


mono_debug_open_method (struct MonoCompile * cfg)
{
  struct MonoMethod * D.22376;
  struct MonoClass * D.22377;
  _Bool D.22378;
  long int D.22379;
  long int D.22380;
  struct GArray * D.22383;
  short unsigned int D.22384;
  unsigned int D.22385;
  unsigned int D.22386;
  unsigned int D.22387;
  void * D.22388;
  struct MiniDebugMethodInfo * info;
  struct MonoDebugMethodJitInfo * jit;
  struct MonoMethodHeader * header;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22374>; else goto <D.22375>;
  <D.22374>:
  return;
  <D.22375>:
  D.22376 = cfg->method;
  D.22377 = D.22376->klass;
  mono_class_init (D.22377);
  header = cfg->header;
  D.22378 = header == 0B;
  D.22379 = (long int) D.22378;
  D.22380 = __builtin_expect (D.22379, 0);
  if (D.22380 != 0) goto <D.22381>; else goto <D.22382>;
  <D.22381>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 77, "header");
  <D.22382>:
  jit = monoeg_malloc0 (56);
  info->jit = jit;
  D.22383 = monoeg_g_array_new (0, 1, 8);
  info->line_numbers = D.22383;
  D.22384 = header->num_locals;
  D.22385 = (unsigned int) D.22384;
  jit->num_locals = D.22385;
  D.22386 = jit->num_locals;
  D.22387 = D.22386 * 24;
  D.22388 = monoeg_malloc0 (D.22387);
  jit->locals = D.22388;
}


mono_debug_close_method (struct MonoCompile * cfg)
{
  struct MonoDebugMethodJitInfo * D.22393;
  unsigned char * D.22396;
  unsigned int D.22397;
  unsigned int D.22398;
  unsigned int D.22399;
  unsigned int D.22402;
  short unsigned int D.22403;
  unsigned int D.22404;
  unsigned int D.22405;
  unsigned int D.22406;
  void * D.22407;
  struct MonoDebugVarInfo * D.22408;
  unsigned int i.0;
  unsigned int D.22410;
  struct MonoDebugVarInfo * D.22411;
  struct MonoInst * * D.22412;
  unsigned int D.22413;
  struct MonoInst * * D.22414;
  struct MonoInst * D.22415;
  unsigned int i.1;
  unsigned int D.22417;
  unsigned char D.22418;
  unsigned char D.22419;
  void * D.22422;
  struct MonoDebugVarInfo * D.22423;
  struct MonoInst * * D.22424;
  struct MonoInst * D.22425;
  struct MonoDebugVarInfo * D.22426;
  struct MonoDebugVarInfo * D.22427;
  <unnamed-unsigned:1> D.22428;
  int D.22429;
  int D.22430;
  unsigned int D.22431;
  unsigned int D.22432;
  struct MonoInst * * D.22433;
  struct MonoInst * D.22434;
  struct MonoInst * D.22435;
  void * D.22438;
  void * D.22439;
  struct MonoDebugVarInfo * D.22440;
  struct MonoDebugVarInfo * D.22441;
  struct MonoInst * D.22442;
  struct GArray * D.22443;
  int D.22444;
  unsigned int D.22445;
  unsigned int D.22446;
  unsigned int D.22447;
  void * D.22448;
  struct MonoDebugLineNumberEntry * D.22449;
  unsigned int D.22450;
  struct MonoDebugLineNumberEntry * D.22451;
  gchar * D.22452;
  struct MonoDebugLineNumberEntry * D.22453;
  struct MonoDomain * D.22454;
  struct MonoMethod * D.22455;
  struct MiniDebugMethodInfo * info;
  struct MonoDebugMethodJitInfo * jit;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  struct MonoDebugMethodAddress * debug_info;
  struct MonoMethod * method;
  int i;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22390>; else goto <D.22392>;
  <D.22392>:
  D.22393 = info->jit;
  if (D.22393 == 0B) goto <D.22390>; else goto <D.22391>;
  <D.22390>:
  if (info != 0B) goto <D.22394>; else goto <D.22395>;
  <D.22394>:
  monoeg_g_free (info);
  <D.22395>:
  return;
  <D.22391>:
  method = cfg->method;
  header = cfg->header;
  sig = mono_method_signature (method);
  jit = info->jit;
  D.22396 = cfg->native_code;
  jit->code_start = D.22396;
  D.22397 = cfg->epilog_begin;
  jit->epilogue_begin = D.22397;
  D.22398 = cfg->code_len;
  jit->code_size = D.22398;
  D.22399 = jit->epilogue_begin;
  if (D.22399 != 0) goto <D.22400>; else goto <D.22401>;
  <D.22400>:
  D.22402 = header->code_size;
  D.22399 = jit->epilogue_begin;
  record_line_number (info, D.22399, D.22402);
  <D.22401>:
  D.22403 = sig->param_count;
  D.22404 = (unsigned int) D.22403;
  jit->num_params = D.22404;
  D.22405 = jit->num_params;
  D.22406 = D.22405 * 24;
  D.22407 = monoeg_malloc0 (D.22406);
  jit->params = D.22407;
  i = 0;
  goto <D.22198>;
  <D.22197>:
  D.22408 = jit->locals;
  i.0 = (unsigned int) i;
  D.22410 = i.0 * 24;
  D.22411 = D.22408 + D.22410;
  D.22412 = cfg->locals;
  i.0 = (unsigned int) i;
  D.22413 = i.0 * 4;
  D.22414 = D.22412 + D.22413;
  D.22415 = *D.22414;
  write_variable (D.22415, D.22411);
  i = i + 1;
  <D.22198>:
  i.1 = (unsigned int) i;
  D.22417 = jit->num_locals;
  if (i.1 < D.22417) goto <D.22197>; else goto <D.22199>;
  <D.22199>:
  D.22418 = BIT_FIELD_REF <*sig, 8, 80>;
  D.22419 = D.22418 & 64;
  if (D.22419 != 0) goto <D.22420>; else goto <D.22421>;
  <D.22420>:
  D.22422 = monoeg_malloc0 (24);
  jit->this_var = D.22422;
  D.22423 = jit->this_var;
  D.22424 = cfg->args;
  D.22425 = *D.22424;
  write_variable (D.22425, D.22423);
  <D.22421>:
  i = 0;
  goto <D.22201>;
  <D.22200>:
  D.22426 = jit->params;
  i.0 = (unsigned int) i;
  D.22410 = i.0 * 24;
  D.22427 = D.22426 + D.22410;
  D.22424 = cfg->args;
  D.22428 = sig->hasthis;
  D.22429 = (int) D.22428;
  D.22430 = D.22429 + i;
  D.22431 = (unsigned int) D.22430;
  D.22432 = D.22431 * 4;
  D.22433 = D.22424 + D.22432;
  D.22434 = *D.22433;
  write_variable (D.22434, D.22427);
  i = i + 1;
  <D.22201>:
  i.1 = (unsigned int) i;
  D.22405 = jit->num_params;
  if (i.1 < D.22405) goto <D.22200>; else goto <D.22202>;
  <D.22202>:
  D.22435 = cfg->gsharedvt_info_var;
  if (D.22435 != 0B) goto <D.22436>; else goto <D.22437>;
  <D.22436>:
  D.22438 = monoeg_malloc0 (24);
  jit->gsharedvt_info_var = D.22438;
  D.22439 = monoeg_malloc0 (24);
  jit->gsharedvt_locals_var = D.22439;
  D.22440 = jit->gsharedvt_info_var;
  D.22435 = cfg->gsharedvt_info_var;
  write_variable (D.22435, D.22440);
  D.22441 = jit->gsharedvt_locals_var;
  D.22442 = cfg->gsharedvt_locals_var;
  write_variable (D.22442, D.22441);
  <D.22437>:
  D.22443 = info->line_numbers;
  D.22444 = D.22443->len;
  D.22445 = (unsigned int) D.22444;
  jit->num_line_numbers = D.22445;
  D.22446 = jit->num_line_numbers;
  D.22447 = D.22446 * 8;
  D.22448 = monoeg_malloc0 (D.22447);
  jit->line_numbers = D.22448;
  i = 0;
  goto <D.22204>;
  <D.22203>:
  D.22449 = jit->line_numbers;
  i.0 = (unsigned int) i;
  D.22450 = i.0 * 8;
  D.22451 = D.22449 + D.22450;
  D.22443 = info->line_numbers;
  D.22452 = D.22443->data;
  i.0 = (unsigned int) i;
  D.22450 = i.0 * 8;
  D.22453 = D.22452 + D.22450;
  *D.22451 = *D.22453;
  i = i + 1;
  <D.22204>:
  i.1 = (unsigned int) i;
  D.22446 = jit->num_line_numbers;
  if (i.1 < D.22446) goto <D.22203>; else goto <D.22205>;
  <D.22205>:
  D.22454 = cfg->domain;
  D.22455 = cfg->method_to_register;
  debug_info = mono_debug_add_method (D.22455, jit, D.22454);
  mono_debug_add_vg_method (method, jit);
  mono_debug_free_method_jit_info (jit);
  mono_debug_free_method (cfg);
}


record_line_number (struct MiniDebugMethodInfo * info, guint32 address, guint32 offset)
{
  struct GArray * D.22457;
  struct MonoDebugLineNumberEntry lne;

  try
    {
      lne.native_offset = address;
      lne.il_offset = offset;
      D.22457 = info->line_numbers;
      monoeg_g_array_append_vals (D.22457, &lne, 1);
    }
  finally
    {
      lne = {CLOBBER};
    }
}


write_variable (struct MonoInst * inst, struct MonoDebugVarInfo * var)
{
  struct MonoType * D.22458;
  short unsigned int D.22459;
  int D.22462;
  unsigned int D.22463;
  unsigned char D.22465;
  int D.22466;
  int D.22467;
  int D.22473;
  int D.22474;
  unsigned int D.22475;
  int D.22476;
  unsigned int D.22477;
  int D.22481;
  unsigned int D.22482;
  int D.22486;
  int D.22487;
  unsigned int D.22488;
  short unsigned int D.22492;
  _Bool D.22493;
  long int D.22494;
  long int D.22495;
  int D.22498;
  unsigned int D.22499;
  int D.22500;
  int D.22501;
  unsigned int D.22502;

  D.22458 = inst->data.op[1].vtype;
  var->type = D.22458;
  D.22459 = inst->opcode;
  if (D.22459 == 366) goto <D.22460>; else goto <D.22461>;
  <D.22460>:
  D.22462 = inst->dreg;
  D.22463 = (unsigned int) D.22462;
  var->index = D.22463;
  goto <D.22464>;
  <D.22461>:
  D.22465 = inst->flags;
  D.22466 = (int) D.22465;
  D.22467 = D.22466 & 2;
  if (D.22467 != 0) goto <D.22468>; else goto <D.22469>;
  <D.22468>:
  var->index = 805306368;
  goto <D.22470>;
  <D.22469>:
  D.22459 = inst->opcode;
  if (D.22459 == 367) goto <D.22471>; else goto <D.22472>;
  <D.22471>:
  D.22473 = inst->sreg1;
  D.22474 = D.22473 | 268435456;
  D.22475 = (unsigned int) D.22474;
  var->index = D.22475;
  D.22476 = inst->data.op[0].const_val;
  D.22477 = (unsigned int) D.22476;
  var->offset = D.22477;
  goto <D.22478>;
  <D.22472>:
  D.22459 = inst->opcode;
  if (D.22459 == 332) goto <D.22479>; else goto <D.22480>;
  <D.22479>:
  D.22473 = inst->sreg1;
  D.22481 = D.22473 | 1073741824;
  D.22482 = (unsigned int) D.22481;
  var->index = D.22482;
  D.22476 = inst->data.op[0].const_val;
  D.22477 = (unsigned int) D.22476;
  var->offset = D.22477;
  goto <D.22483>;
  <D.22480>:
  D.22459 = inst->opcode;
  if (D.22459 == 331) goto <D.22484>; else goto <D.22485>;
  <D.22484>:
  D.22486 = inst->data.op[1].const_val;
  D.22487 = D.22486 | 1342177280;
  D.22488 = (unsigned int) D.22487;
  var->index = D.22488;
  goto <D.22489>;
  <D.22485>:
  D.22459 = inst->opcode;
  if (D.22459 == 368) goto <D.22490>; else goto <D.22491>;
  <D.22490>:
  {
    struct MonoInst * vtaddr;

    vtaddr = inst->data.op[0].src;
    D.22492 = vtaddr->opcode;
    D.22493 = D.22492 != 367;
    D.22494 = (long int) D.22493;
    D.22495 = __builtin_expect (D.22494, 0);
    if (D.22495 != 0) goto <D.22496>; else goto <D.22497>;
    <D.22496>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 107, "vtaddr->opcode == OP_REGOFFSET");
    <D.22497>:
    D.22498 = vtaddr->data.op[0].const_val;
    D.22499 = (unsigned int) D.22498;
    var->offset = D.22499;
    D.22500 = vtaddr->sreg1;
    D.22501 = D.22500 | 1610612736;
    D.22502 = (unsigned int) D.22501;
    var->index = D.22502;
  }
  goto <D.22503>;
  <D.22491>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 111);
  <D.22503>:
  <D.22489>:
  <D.22483>:
  <D.22478>:
  <D.22470>:
  <D.22464>:
}


mono_debug_add_vg_method (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit)
{

}


mono_debug_free_method (struct MonoCompile * cfg)
{
  struct GArray * D.22506;
  struct MiniDebugMethodInfo * info;

  info = cfg->debug_info;
  if (info != 0B) goto <D.22504>; else goto <D.22505>;
  <D.22504>:
  D.22506 = info->line_numbers;
  if (D.22506 != 0B) goto <D.22507>; else goto <D.22508>;
  <D.22507>:
  D.22506 = info->line_numbers;
  monoeg_g_array_free (D.22506, 1);
  <D.22508>:
  monoeg_g_free (info);
  cfg->debug_info = 0B;
  <D.22505>:
}


mono_debug_record_line_number (struct MonoCompile * cfg, struct MonoInst * ins, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.22512;
  const unsigned char * D.22514;
  _Bool D.22515;
  long int D.22516;
  long int D.22517;
  const unsigned char * D.22522;
  unsigned int D.22524;
  const unsigned char * D.22525;
  int D.22526;
  int D.22527;
  int D.22528;
  unsigned int D.22529;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22509>; else goto <D.22511>;
  <D.22511>:
  D.22512 = info->jit;
  if (D.22512 == 0B) goto <D.22509>; else goto <D.22513>;
  <D.22513>:
  D.22514 = ins->cil_code;
  if (D.22514 == 0B) goto <D.22509>; else goto <D.22510>;
  <D.22509>:
  return;
  <D.22510>:
  header = cfg->header;
  D.22515 = header == 0B;
  D.22516 = (long int) D.22515;
  D.22517 = __builtin_expect (D.22516, 0);
  if (D.22517 != 0) goto <D.22518>; else goto <D.22519>;
  <D.22518>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 308, "header");
  <D.22519>:
  D.22514 = ins->cil_code;
  D.22522 = header->code;
  if (D.22514 < D.22522) goto <D.22520>; else goto <D.22523>;
  <D.22523>:
  D.22514 = ins->cil_code;
  D.22522 = header->code;
  D.22524 = header->code_size;
  D.22525 = D.22522 + D.22524;
  if (D.22514 > D.22525) goto <D.22520>; else goto <D.22521>;
  <D.22520>:
  return;
  <D.22521>:
  D.22514 = ins->cil_code;
  D.22526 = (int) D.22514;
  D.22522 = header->code;
  D.22527 = (int) D.22522;
  D.22528 = D.22526 - D.22527;
  offset = (guint32) D.22528;
  D.22529 = info->has_line_numbers;
  if (D.22529 == 0) goto <D.22530>; else goto <D.22531>;
  <D.22530>:
  D.22512 = info->jit;
  D.22512->prologue_end = address;
  info->has_line_numbers = 1;
  <D.22531>:
  record_line_number (info, address, offset);
}


mono_debug_open_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.22536;
  unsigned char * D.22538;
  _Bool D.22539;
  long int D.22540;
  long int D.22541;
  const unsigned char * D.22546;
  unsigned int D.22548;
  const unsigned char * D.22549;
  int D.22550;
  int D.22551;
  int D.22552;
  unsigned int D.22553;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22533>; else goto <D.22535>;
  <D.22535>:
  D.22536 = info->jit;
  if (D.22536 == 0B) goto <D.22533>; else goto <D.22537>;
  <D.22537>:
  D.22538 = bb->cil_code;
  if (D.22538 == 0B) goto <D.22533>; else goto <D.22534>;
  <D.22533>:
  return;
  <D.22534>:
  header = cfg->header;
  D.22539 = header == 0B;
  D.22540 = (long int) D.22539;
  D.22541 = __builtin_expect (D.22540, 0);
  if (D.22541 != 0) goto <D.22542>; else goto <D.22543>;
  <D.22542>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 335, "header");
  <D.22543>:
  D.22538 = bb->cil_code;
  D.22546 = header->code;
  if (D.22538 < D.22546) goto <D.22544>; else goto <D.22547>;
  <D.22547>:
  D.22538 = bb->cil_code;
  D.22546 = header->code;
  D.22548 = header->code_size;
  D.22549 = D.22546 + D.22548;
  if (D.22538 > D.22549) goto <D.22544>; else goto <D.22545>;
  <D.22544>:
  return;
  <D.22545>:
  D.22538 = bb->cil_code;
  D.22550 = (int) D.22538;
  D.22546 = header->code;
  D.22551 = (int) D.22546;
  D.22552 = D.22550 - D.22551;
  offset = (guint32) D.22552;
  D.22553 = info->has_line_numbers;
  if (D.22553 == 0) goto <D.22554>; else goto <D.22555>;
  <D.22554>:
  D.22536 = info->jit;
  D.22536->prologue_end = address;
  info->has_line_numbers = 1;
  <D.22555>:
  record_line_number (info, address, offset);
}


mono_debug_serialize_debug_info (struct MonoCompile * cfg, guint8 * * out_buf, guint32 * buf_len)
{
  struct MonoDomain * D.22557;
  struct MonoMethod * D.22558;
  unsigned int D.22561;
  unsigned int D.22562;
  unsigned int D.22563;
  unsigned int D.22564;
  unsigned int D.22565;
  unsigned int D.22566;
  unsigned int D.22567;
  guint8 * p.2;
  unsigned int D.22569;
  int D.22570;
  unsigned int D.22571;
  int D.22572;
  unsigned int D.22573;
  int D.22574;
  struct MonoDebugVarInfo * D.22575;
  unsigned int i.3;
  unsigned int D.22577;
  struct MonoDebugVarInfo * D.22578;
  unsigned int i.4;
  struct MonoMethodSignature * D.22580;
  unsigned char D.22581;
  unsigned char D.22582;
  struct MonoDebugVarInfo * D.22585;
  struct MonoDebugVarInfo * D.22586;
  struct MonoDebugVarInfo * D.22587;
  struct MonoDebugVarInfo * D.22588;
  struct MonoDebugVarInfo * D.22591;
  int D.22593;
  struct MonoDebugLineNumberEntry * D.22594;
  unsigned int D.22595;
  unsigned int D.22596;
  unsigned int D.22597;
  int D.22598;
  unsigned int D.22599;
  unsigned int D.22600;
  int D.22601;
  int p.5;
  int buf.6;
  int D.22604;
  unsigned int D.22605;
  _Bool D.22606;
  long int D.22607;
  long int D.22608;
  struct MonoDebugMethodJitInfo * jit;
  guint32 size;
  guint32 prev_offset;
  guint32 prev_native_offset;
  guint8 * buf;
  guint8 * p;
  int i;

  try
    {
      D.22557 = mono_domain_get ();
      D.22558 = cfg->method;
      jit = mono_debug_find_method (D.22558, D.22557);
      if (jit == 0B) goto <D.22559>; else goto <D.22560>;
      <D.22559>:
      *buf_len = 0;
      return;
      <D.22560>:
      D.22561 = jit->num_params;
      D.22562 = jit->num_locals;
      D.22563 = D.22561 + D.22562;
      D.22564 = jit->num_line_numbers;
      D.22565 = D.22563 + D.22564;
      D.22566 = D.22565 + 1;
      D.22567 = D.22566 * 10;
      size = D.22567 + 64;
      buf = monoeg_malloc (size);
      p = buf;
      p.2 = p;
      D.22569 = jit->epilogue_begin;
      D.22570 = (int) D.22569;
      encode_value (D.22570, p.2, &p);
      p.2 = p;
      D.22571 = jit->prologue_end;
      D.22572 = (int) D.22571;
      encode_value (D.22572, p.2, &p);
      p.2 = p;
      D.22573 = jit->code_size;
      D.22574 = (int) D.22573;
      encode_value (D.22574, p.2, &p);
      i = 0;
      goto <D.22265>;
      <D.22264>:
      p.2 = p;
      D.22575 = jit->params;
      i.3 = (unsigned int) i;
      D.22577 = i.3 * 24;
      D.22578 = D.22575 + D.22577;
      serialize_variable (D.22578, p.2, &p);
      i = i + 1;
      <D.22265>:
      i.4 = (unsigned int) i;
      D.22561 = jit->num_params;
      if (i.4 < D.22561) goto <D.22264>; else goto <D.22266>;
      <D.22266>:
      D.22558 = cfg->method;
      D.22580 = mono_method_signature (D.22558);
      D.22581 = BIT_FIELD_REF <*D.22580, 8, 80>;
      D.22582 = D.22581 & 64;
      if (D.22582 != 0) goto <D.22583>; else goto <D.22584>;
      <D.22583>:
      p.2 = p;
      D.22585 = jit->this_var;
      serialize_variable (D.22585, p.2, &p);
      <D.22584>:
      i = 0;
      goto <D.22268>;
      <D.22267>:
      p.2 = p;
      D.22586 = jit->locals;
      i.3 = (unsigned int) i;
      D.22577 = i.3 * 24;
      D.22587 = D.22586 + D.22577;
      serialize_variable (D.22587, p.2, &p);
      i = i + 1;
      <D.22268>:
      i.4 = (unsigned int) i;
      D.22562 = jit->num_locals;
      if (i.4 < D.22562) goto <D.22267>; else goto <D.22269>;
      <D.22269>:
      D.22588 = jit->gsharedvt_info_var;
      if (D.22588 != 0B) goto <D.22589>; else goto <D.22590>;
      <D.22589>:
      p.2 = p;
      encode_value (1, p.2, &p);
      p.2 = p;
      D.22588 = jit->gsharedvt_info_var;
      serialize_variable (D.22588, p.2, &p);
      p.2 = p;
      D.22591 = jit->gsharedvt_locals_var;
      serialize_variable (D.22591, p.2, &p);
      goto <D.22592>;
      <D.22590>:
      p.2 = p;
      encode_value (0, p.2, &p);
      <D.22592>:
      p.2 = p;
      D.22564 = jit->num_line_numbers;
      D.22593 = (int) D.22564;
      encode_value (D.22593, p.2, &p);
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22272>;
      <D.22271>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.22594 = jit->line_numbers;
        i.3 = (unsigned int) i;
        D.22595 = i.3 * 8;
        lne = D.22594 + D.22595;
        p.2 = p;
        D.22596 = lne->il_offset;
        D.22597 = D.22596 - prev_offset;
        D.22598 = (int) D.22597;
        encode_value (D.22598, p.2, &p);
        p.2 = p;
        D.22599 = lne->native_offset;
        D.22600 = D.22599 - prev_native_offset;
        D.22601 = (int) D.22600;
        encode_value (D.22601, p.2, &p);
        prev_offset = lne->il_offset;
        prev_native_offset = lne->native_offset;
      }
      i = i + 1;
      <D.22272>:
      i.4 = (unsigned int) i;
      D.22564 = jit->num_line_numbers;
      if (i.4 < D.22564) goto <D.22271>; else goto <D.22273>;
      <D.22273>:
      p.2 = p;
      p.5 = (int) p.2;
      buf.6 = (int) buf;
      D.22604 = p.5 - buf.6;
      D.22605 = (unsigned int) D.22604;
      D.22606 = D.22605 >= size;
      D.22607 = (long int) D.22606;
      D.22608 = __builtin_expect (D.22607, 0);
      if (D.22608 != 0) goto <D.22609>; else goto <D.22610>;
      <D.22609>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 491, "p - buf < size");
      <D.22610>:
      *out_buf = buf;
      p.2 = p;
      p.5 = (int) p.2;
      buf.6 = (int) buf;
      D.22604 = p.5 - buf.6;
      D.22605 = (unsigned int) D.22604;
      *buf_len = D.22605;
    }
  finally
    {
      p = {CLOBBER};
    }
}


serialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  unsigned int D.22614;
  guint8 * p.7;
  int D.22616;
  unsigned int D.22617;
  int D.22618;
  guint32 flags;

  D.22614 = var->index;
  flags = D.22614 & 4026531840;
  p.7 = p;
  D.22614 = var->index;
  D.22616 = (int) D.22614;
  encode_value (D.22616, p.7, &p);
  switch (flags) <default: <D.22251>, case 0: <D.22244>, case 268435456: <D.22246>, case 805306368: <D.22250>, case 1073741824: <D.22247>, case 1342177280: <D.22248>, case 1610612736: <D.22249>>
  <D.22244>:
  goto <D.22245>;
  <D.22246>:
  <D.22247>:
  p.7 = p;
  D.22617 = var->offset;
  D.22618 = (int) D.22617;
  encode_value (D.22618, p.7, &p);
  goto <D.22245>;
  <D.22248>:
  <D.22249>:
  <D.22250>:
  goto <D.22245>;
  <D.22251>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 435);
  <D.22245>:
  p.7 = p;
  *endbuf = p.7;
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.8;
  guint8 * p.9;
  unsigned char D.22624;
  int D.22628;
  signed char D.22629;
  signed char D.22630;
  unsigned char D.22631;
  guint8 * D.22632;
  unsigned char D.22633;
  int D.22637;
  signed char D.22638;
  signed char D.22639;
  unsigned char D.22640;
  int D.22641;
  unsigned char D.22642;
  guint8 * D.22643;
  unsigned char D.22644;
  guint8 * D.22645;
  unsigned int D.22647;
  unsigned char D.22648;
  guint8 * D.22649;
  guint8 * p;

  p = buf;
  value.8 = (unsigned int) value;
  if (value.8 <= 127) goto <D.22621>; else goto <D.22622>;
  <D.22621>:
  p.9 = p;
  p = p.9 + 1;
  D.22624 = (unsigned char) value;
  *p.9 = D.22624;
  goto <D.22625>;
  <D.22622>:
  value.8 = (unsigned int) value;
  if (value.8 <= 16383) goto <D.22626>; else goto <D.22627>;
  <D.22626>:
  D.22628 = value >> 8;
  D.22629 = (signed char) D.22628;
  D.22630 = D.22629 | -128;
  D.22631 = (unsigned char) D.22630;
  *p = D.22631;
  D.22632 = p + 1;
  D.22633 = (unsigned char) value;
  *D.22632 = D.22633;
  p = p + 2;
  goto <D.22634>;
  <D.22627>:
  value.8 = (unsigned int) value;
  if (value.8 <= 536870911) goto <D.22635>; else goto <D.22636>;
  <D.22635>:
  D.22637 = value >> 24;
  D.22638 = (signed char) D.22637;
  D.22639 = D.22638 | -64;
  D.22640 = (unsigned char) D.22639;
  *p = D.22640;
  D.22632 = p + 1;
  D.22641 = value >> 16;
  D.22642 = (unsigned char) D.22641;
  *D.22632 = D.22642;
  D.22643 = p + 2;
  D.22628 = value >> 8;
  D.22644 = (unsigned char) D.22628;
  *D.22643 = D.22644;
  D.22645 = p + 3;
  D.22633 = (unsigned char) value;
  *D.22645 = D.22633;
  p = p + 4;
  goto <D.22646>;
  <D.22636>:
  *p = 255;
  D.22632 = p + 1;
  value.8 = (unsigned int) value;
  D.22647 = value.8 >> 24;
  D.22648 = (unsigned char) D.22647;
  *D.22632 = D.22648;
  D.22643 = p + 2;
  D.22641 = value >> 16;
  D.22642 = (unsigned char) D.22641;
  *D.22643 = D.22642;
  D.22645 = p + 3;
  D.22628 = value >> 8;
  D.22644 = (unsigned char) D.22628;
  *D.22645 = D.22644;
  D.22649 = p + 4;
  D.22633 = (unsigned char) value;
  *D.22649 = D.22633;
  p = p + 5;
  <D.22646>:
  <D.22634>:
  <D.22625>:
  if (endbuf != 0B) goto <D.22650>; else goto <D.22651>;
  <D.22650>:
  *endbuf = p;
  <D.22651>:
}


mono_debug_add_aot_method (struct MonoDomain * domain, struct MonoMethod * method, guint8 * code_start, guint8 * debug_info, guint32 debug_info_len)
{
  int D.22652;
  short unsigned int D.22657;
  unsigned int D.22658;
  unsigned int D.22659;
  short unsigned int D.22661;
  unsigned int D.22662;
  unsigned int D.22663;
  unsigned char D.22665;
  unsigned char D.22666;
  struct MonoDebugMethodJitInfo * jit;

  D.22652 = mono_debug_enabled ();
  if (D.22652 == 0) goto <D.22653>; else goto <D.22654>;
  <D.22653>:
  return;
  <D.22654>:
  D.22657 = method->iflags;
  D.22658 = (unsigned int) D.22657;
  D.22659 = D.22658 & 4099;
  if (D.22659 != 0) goto <D.22655>; else goto <D.22660>;
  <D.22660>:
  D.22661 = method->flags;
  D.22662 = (unsigned int) D.22661;
  D.22663 = D.22662 & 9216;
  if (D.22663 != 0) goto <D.22655>; else goto <D.22664>;
  <D.22664>:
  D.22665 = BIT_FIELD_REF <*method, 8, 160>;
  D.22666 = D.22665 & 124;
  if (D.22666 != 0) goto <D.22655>; else goto <D.22656>;
  <D.22655>:
  return;
  <D.22656>:
  if (debug_info_len == 0) goto <D.22667>; else goto <D.22668>;
  <D.22667>:
  return;
  <D.22668>:
  jit = deserialize_debug_info (method, code_start, debug_info, debug_info_len);
  mono_debug_add_method (method, jit, domain);
  mono_debug_add_vg_method (method, jit);
  mono_debug_free_method_jit_info (jit);
}


deserialize_debug_info (struct MonoMethod * method, guint8 * code_start, guint8 * buf, guint32 buf_len)
{
  _Bool D.22670;
  long int D.22671;
  long int D.22672;
  short unsigned int D.22675;
  unsigned int D.22676;
  unsigned int D.22677;
  unsigned int D.22678;
  void * D.22679;
  struct MonoMethodSignature * D.22680;
  short unsigned int D.22681;
  unsigned int D.22682;
  unsigned int D.22683;
  unsigned int D.22684;
  void * D.22685;
  guint8 * p.10;
  int D.22687;
  unsigned int D.22688;
  int D.22689;
  unsigned int D.22690;
  int D.22691;
  unsigned int D.22692;
  struct MonoDebugVarInfo * D.22693;
  unsigned int i.11;
  unsigned int D.22695;
  struct MonoDebugVarInfo * D.22696;
  unsigned int i.12;
  struct MonoMethodSignature * D.22698;
  unsigned char D.22699;
  unsigned char D.22700;
  void * D.22703;
  struct MonoDebugVarInfo * D.22704;
  struct MonoDebugVarInfo * D.22705;
  struct MonoDebugVarInfo * D.22706;
  int D.22707;
  void * D.22710;
  void * D.22711;
  struct MonoDebugVarInfo * D.22712;
  struct MonoDebugVarInfo * D.22713;
  int D.22714;
  unsigned int D.22715;
  unsigned int D.22716;
  unsigned int D.22717;
  void * D.22718;
  struct MonoDebugLineNumberEntry * D.22719;
  unsigned int D.22720;
  int D.22721;
  int D.22722;
  unsigned int native_offset.13;
  unsigned int offset.14;
  struct MonoDebugMethodJitInfo * D.22725;
  struct MonoMethodHeader * header;
  gint32 offset;
  gint32 native_offset;
  gint32 prev_offset;
  gint32 prev_native_offset;
  struct MonoDebugMethodJitInfo * jit;
  guint8 * p;
  int i;

  try
    {
      header = mono_method_get_header (method);
      D.22670 = header == 0B;
      D.22671 = (long int) D.22670;
      D.22672 = __builtin_expect (D.22671, 0);
      if (D.22672 != 0) goto <D.22673>; else goto <D.22674>;
      <D.22673>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 533, "header");
      <D.22674>:
      jit = monoeg_malloc0 (56);
      jit->code_start = code_start;
      D.22675 = header->num_locals;
      D.22676 = (unsigned int) D.22675;
      jit->num_locals = D.22676;
      D.22677 = jit->num_locals;
      D.22678 = D.22677 * 24;
      D.22679 = monoeg_malloc0 (D.22678);
      jit->locals = D.22679;
      D.22680 = mono_method_signature (method);
      D.22681 = D.22680->param_count;
      D.22682 = (unsigned int) D.22681;
      jit->num_params = D.22682;
      D.22683 = jit->num_params;
      D.22684 = D.22683 * 24;
      D.22685 = monoeg_malloc0 (D.22684);
      jit->params = D.22685;
      p = buf;
      p.10 = p;
      D.22687 = decode_value (p.10, &p);
      D.22688 = (unsigned int) D.22687;
      jit->epilogue_begin = D.22688;
      p.10 = p;
      D.22689 = decode_value (p.10, &p);
      D.22690 = (unsigned int) D.22689;
      jit->prologue_end = D.22690;
      p.10 = p;
      D.22691 = decode_value (p.10, &p);
      D.22692 = (unsigned int) D.22691;
      jit->code_size = D.22692;
      i = 0;
      goto <D.22303>;
      <D.22302>:
      p.10 = p;
      D.22693 = jit->params;
      i.11 = (unsigned int) i;
      D.22695 = i.11 * 24;
      D.22696 = D.22693 + D.22695;
      deserialize_variable (D.22696, p.10, &p);
      i = i + 1;
      <D.22303>:
      i.12 = (unsigned int) i;
      D.22683 = jit->num_params;
      if (i.12 < D.22683) goto <D.22302>; else goto <D.22304>;
      <D.22304>:
      D.22698 = mono_method_signature (method);
      D.22699 = BIT_FIELD_REF <*D.22698, 8, 80>;
      D.22700 = D.22699 & 64;
      if (D.22700 != 0) goto <D.22701>; else goto <D.22702>;
      <D.22701>:
      D.22703 = monoeg_malloc0 (24);
      jit->this_var = D.22703;
      p.10 = p;
      D.22704 = jit->this_var;
      deserialize_variable (D.22704, p.10, &p);
      <D.22702>:
      i = 0;
      goto <D.22306>;
      <D.22305>:
      p.10 = p;
      D.22705 = jit->locals;
      i.11 = (unsigned int) i;
      D.22695 = i.11 * 24;
      D.22706 = D.22705 + D.22695;
      deserialize_variable (D.22706, p.10, &p);
      i = i + 1;
      <D.22306>:
      i.12 = (unsigned int) i;
      D.22677 = jit->num_locals;
      if (i.12 < D.22677) goto <D.22305>; else goto <D.22307>;
      <D.22307>:
      p.10 = p;
      D.22707 = decode_value (p.10, &p);
      if (D.22707 != 0) goto <D.22708>; else goto <D.22709>;
      <D.22708>:
      D.22710 = monoeg_malloc0 (24);
      jit->gsharedvt_info_var = D.22710;
      D.22711 = monoeg_malloc0 (24);
      jit->gsharedvt_locals_var = D.22711;
      p.10 = p;
      D.22712 = jit->gsharedvt_info_var;
      deserialize_variable (D.22712, p.10, &p);
      p.10 = p;
      D.22713 = jit->gsharedvt_locals_var;
      deserialize_variable (D.22713, p.10, &p);
      <D.22709>:
      p.10 = p;
      D.22714 = decode_value (p.10, &p);
      D.22715 = (unsigned int) D.22714;
      jit->num_line_numbers = D.22715;
      D.22716 = jit->num_line_numbers;
      D.22717 = D.22716 * 8;
      D.22718 = monoeg_malloc0 (D.22717);
      jit->line_numbers = D.22718;
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22310>;
      <D.22309>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.22719 = jit->line_numbers;
        i.11 = (unsigned int) i;
        D.22720 = i.11 * 8;
        lne = D.22719 + D.22720;
        p.10 = p;
        D.22721 = decode_value (p.10, &p);
        offset = D.22721 + prev_offset;
        p.10 = p;
        D.22722 = decode_value (p.10, &p);
        native_offset = D.22722 + prev_native_offset;
        native_offset.13 = (unsigned int) native_offset;
        lne->native_offset = native_offset.13;
        offset.14 = (unsigned int) offset;
        lne->il_offset = offset.14;
        prev_offset = offset;
        prev_native_offset = native_offset;
      }
      i = i + 1;
      <D.22310>:
      i.12 = (unsigned int) i;
      D.22716 = jit->num_line_numbers;
      if (i.12 < D.22716) goto <D.22309>; else goto <D.22311>;
      <D.22311>:
      mono_metadata_free_mh (header);
      D.22725 = jit;
      return D.22725;
    }
  finally
    {
      p = {CLOBBER};
    }
}


deserialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  guint8 * p.15;
  int D.22729;
  unsigned int D.22730;
  unsigned int D.22731;
  int D.22732;
  unsigned int D.22733;
  guint32 flags;

  p.15 = p;
  D.22729 = decode_value (p.15, &p);
  D.22730 = (unsigned int) D.22729;
  var->index = D.22730;
  D.22731 = var->index;
  flags = D.22731 & 4026531840;
  switch (flags) <default: <D.22287>, case 0: <D.22280>, case 268435456: <D.22282>, case 805306368: <D.22286>, case 1073741824: <D.22283>, case 1342177280: <D.22284>, case 1610612736: <D.22285>>
  <D.22280>:
  goto <D.22281>;
  <D.22282>:
  <D.22283>:
  p.15 = p;
  D.22732 = decode_value (p.15, &p);
  D.22733 = (unsigned int) D.22732;
  var->offset = D.22733;
  goto <D.22281>;
  <D.22284>:
  <D.22285>:
  <D.22286>:
  goto <D.22281>;
  <D.22287>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 518);
  <D.22281>:
  p.15 = p;
  *endbuf = p.15;
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.16;
  int D.22739;
  int D.22740;
  int D.22743;
  int D.22744;
  guint8 * D.22745;
  unsigned char D.22746;
  int D.22747;
  int D.22751;
  int D.22752;
  int D.22753;
  int D.22754;
  guint8 * D.22755;
  unsigned char D.22756;
  int D.22757;
  int D.22758;
  int D.22759;
  guint8 * D.22760;
  unsigned char D.22761;
  int D.22762;
  int D.22764;
  int D.22765;
  int D.22766;
  int D.22767;
  int D.22768;
  guint8 * D.22769;
  unsigned char D.22770;
  int D.22771;
  gint32 D.22774;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.16 = (signed char) b;
  if (b.16 >= 0) goto <D.22736>; else goto <D.22737>;
  <D.22736>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.22738>;
  <D.22737>:
  D.22739 = (int) b;
  D.22740 = D.22739 & 64;
  if (D.22740 == 0) goto <D.22741>; else goto <D.22742>;
  <D.22741>:
  D.22739 = (int) b;
  D.22743 = D.22739 & 63;
  D.22744 = D.22743 << 8;
  D.22745 = ptr + 1;
  D.22746 = *D.22745;
  D.22747 = (int) D.22746;
  len = D.22744 | D.22747;
  ptr = ptr + 2;
  goto <D.22748>;
  <D.22742>:
  if (b != 255) goto <D.22749>; else goto <D.22750>;
  <D.22749>:
  D.22739 = (int) b;
  D.22751 = D.22739 & 31;
  D.22752 = D.22751 << 24;
  D.22745 = ptr + 1;
  D.22746 = *D.22745;
  D.22747 = (int) D.22746;
  D.22753 = D.22747 << 16;
  D.22754 = D.22752 | D.22753;
  D.22755 = ptr + 2;
  D.22756 = *D.22755;
  D.22757 = (int) D.22756;
  D.22758 = D.22757 << 8;
  D.22759 = D.22754 | D.22758;
  D.22760 = ptr + 3;
  D.22761 = *D.22760;
  D.22762 = (int) D.22761;
  len = D.22759 | D.22762;
  ptr = ptr + 4;
  goto <D.22763>;
  <D.22750>:
  D.22745 = ptr + 1;
  D.22746 = *D.22745;
  D.22747 = (int) D.22746;
  D.22764 = D.22747 << 24;
  D.22755 = ptr + 2;
  D.22756 = *D.22755;
  D.22757 = (int) D.22756;
  D.22765 = D.22757 << 16;
  D.22766 = D.22764 | D.22765;
  D.22760 = ptr + 3;
  D.22761 = *D.22760;
  D.22762 = (int) D.22761;
  D.22767 = D.22762 << 8;
  D.22768 = D.22766 | D.22767;
  D.22769 = ptr + 4;
  D.22770 = *D.22769;
  D.22771 = (int) D.22770;
  len = D.22768 | D.22771;
  ptr = ptr + 5;
  <D.22763>:
  <D.22748>:
  <D.22738>:
  if (rptr != 0B) goto <D.22772>; else goto <D.22773>;
  <D.22772>:
  *rptr = ptr;
  <D.22773>:
  D.22774 = len;
  return D.22774;
}


mono_debug_print_vars (void * ip, gboolean only_arguments)
{
  struct MonoMethod * D.22778;
  unsigned int D.22783;
  unsigned int D.22784;
  struct MonoMethod * D.22785;
  struct MonoDebugVarInfo * D.22786;
  const char * iftmp.17;
  unsigned int i.18;
  unsigned int D.22791;
  char * * D.22792;
  char * D.22793;
  struct MonoDebugVarInfo * D.22797;
  unsigned int D.22798;
  struct MonoDebugVarInfo * D.22799;
  unsigned int i.19;
  struct MonoDebugVarInfo * D.22802;
  struct MonoDebugVarInfo * D.22803;
  unsigned int D.22804;
  struct MonoDomain * domain;
  struct MonoJitInfo * ji;
  struct MonoDebugMethodJitInfo * jit;
  int i;

  domain = mono_domain_get ();
  ji = mono_jit_info_table_find (domain, ip);
  if (ji == 0B) goto <D.22776>; else goto <D.22777>;
  <D.22776>:
  return;
  <D.22777>:
  D.22778 = jinfo_get_method (ji);
  jit = mono_debug_find_method (D.22778, domain);
  if (jit == 0B) goto <D.22779>; else goto <D.22780>;
  <D.22779>:
  return;
  <D.22780>:
  if (only_arguments != 0) goto <D.22781>; else goto <D.22782>;
  <D.22781>:
  {
    char * * names;

    D.22783 = jit->num_params;
    D.22784 = D.22783 * 4;
    names = monoeg_malloc (D.22784);
    D.22785 = jinfo_get_method (ji);
    mono_method_get_param_names (D.22785, names);
    D.22786 = jit->this_var;
    if (D.22786 != 0B) goto <D.22787>; else goto <D.22788>;
    <D.22787>:
    D.22786 = jit->this_var;
    print_var_info (D.22786, 0, "this", "Arg");
    <D.22788>:
    i = 0;
    goto <D.22344>;
    <D.22343>:
    i.18 = (unsigned int) i;
    D.22791 = i.18 * 4;
    D.22792 = names + D.22791;
    D.22793 = *D.22792;
    if (D.22793 != 0B) goto <D.22794>; else goto <D.22795>;
    <D.22794>:
    i.18 = (unsigned int) i;
    D.22791 = i.18 * 4;
    D.22792 = names + D.22791;
    iftmp.17 = *D.22792;
    goto <D.22796>;
    <D.22795>:
    iftmp.17 = "unknown name";
    <D.22796>:
    D.22797 = jit->params;
    i.18 = (unsigned int) i;
    D.22798 = i.18 * 24;
    D.22799 = D.22797 + D.22798;
    print_var_info (D.22799, i, iftmp.17, "Arg");
    i = i + 1;
    <D.22344>:
    i.19 = (unsigned int) i;
    D.22783 = jit->num_params;
    if (i.19 < D.22783) goto <D.22343>; else goto <D.22345>;
    <D.22345>:
    monoeg_g_free (names);
  }
  goto <D.22801>;
  <D.22782>:
  i = 0;
  goto <D.22347>;
  <D.22346>:
  D.22802 = jit->locals;
  i.18 = (unsigned int) i;
  D.22798 = i.18 * 24;
  D.22803 = D.22802 + D.22798;
  print_var_info (D.22803, i, "", "Local");
  i = i + 1;
  <D.22347>:
  i.19 = (unsigned int) i;
  D.22804 = jit->num_locals;
  if (i.19 < D.22804) goto <D.22346>; else goto <D.22348>;
  <D.22348>:
  <D.22801>:
  mono_debug_free_method_jit_info (jit);
}


jinfo_get_method (struct MonoJitInfo * ji)
{
  struct MonoMethod * D.22806;

  D.22806 = mono_jit_info_get_method (ji);
  return D.22806;
}


print_var_info (struct MonoDebugVarInfo * info, int idx, const char * name, const char * type)
{
  unsigned int D.22808;
  unsigned int D.22809;
  int D.22810;
  int D.22811;
  const char * D.22812;
  unsigned int D.22813;
  const char * D.22814;
  const char * D.22815;
  const char * D.22816;

  D.22808 = info->index;
  D.22809 = D.22808 & 4026531840;
  switch (D.22809) <default: <D.22333>, case 0: <D.22326>, case 268435456: <D.22328>, case 536870912: <D.22332>, case 1073741824: <D.22329>, case 1342177280: <D.22330>, case 1610612736: <D.22331>>
  <D.22326>:
  D.22808 = info->index;
  D.22810 = (int) D.22808;
  D.22811 = D.22810 & 268435455;
  D.22812 = mono_arch_regname (D.22811);
  monoeg_g_print ("%s %s (%d) in register %s\n", type, name, idx, D.22812);
  goto <D.22327>;
  <D.22328>:
  D.22813 = info->offset;
  D.22808 = info->index;
  D.22810 = (int) D.22808;
  D.22811 = D.22810 & 268435455;
  D.22814 = mono_arch_regname (D.22811);
  monoeg_g_print ("%s %s (%d) in memory: base register %s + %d\n", type, name, idx, D.22814, D.22813);
  goto <D.22327>;
  <D.22329>:
  D.22813 = info->offset;
  D.22808 = info->index;
  D.22810 = (int) D.22808;
  D.22811 = D.22810 & 268435455;
  D.22815 = mono_arch_regname (D.22811);
  monoeg_g_print ("%s %s (%d) in indir memory: base register %s + %d\n", type, name, idx, D.22815, D.22813);
  goto <D.22327>;
  <D.22330>:
  monoeg_g_print ("%s %s (%d) gsharedvt local.\n", type, name, idx);
  goto <D.22327>;
  <D.22331>:
  D.22813 = info->offset;
  D.22808 = info->index;
  D.22810 = (int) D.22808;
  D.22811 = D.22810 & 268435455;
  D.22816 = mono_arch_regname (D.22811);
  monoeg_g_print ("%s %s (%d) vt address: base register %s + %d\n", type, name, idx, D.22816, D.22813);
  goto <D.22327>;
  <D.22332>:
  <D.22333>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 636);
  <D.22327>:
}


mono_debugger_insert_breakpoint (const gchar * method_name, gboolean include_namespace)
{
  int D.22819;
  struct MonoMethodDesc * desc;

  desc = mono_method_desc_new (method_name, include_namespace);
  if (desc == 0B) goto <D.22817>; else goto <D.22818>;
  <D.22817>:
  D.22819 = 0;
  return D.22819;
  <D.22818>:
  D.22819 = mono_debugger_insert_breakpoint_full (desc);
  return D.22819;
}


mono_debugger_insert_breakpoint_full (struct MonoMethodDesc * desc)
{
  int last_breakpoint_id.20;
  int last_breakpoint_id.21;
  unsigned int last_breakpoint_id.22;
  struct GPtrArray * breakpoints.23;
  struct GPtrArray * breakpoints.24;
  int D.22828;
  unsigned int D.22829;
  static int last_breakpoint_id = 0;
  struct MiniDebugBreakpointInfo * info;

  info = monoeg_malloc0 (8);
  info->desc = desc;
  last_breakpoint_id.20 = last_breakpoint_id;
  last_breakpoint_id.21 = last_breakpoint_id.20 + 1;
  last_breakpoint_id = last_breakpoint_id.21;
  last_breakpoint_id.20 = last_breakpoint_id;
  last_breakpoint_id.22 = (unsigned int) last_breakpoint_id.20;
  info->index = last_breakpoint_id.22;
  breakpoints.23 = breakpoints;
  if (breakpoints.23 == 0B) goto <D.22825>; else goto <D.22826>;
  <D.22825>:
  breakpoints.24 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.24;
  <D.22826>:
  breakpoints.23 = breakpoints;
  monoeg_g_ptr_array_add (breakpoints.23, info);
  D.22829 = info->index;
  D.22828 = (int) D.22829;
  return D.22828;
}


mono_debugger_method_has_breakpoint (struct MonoMethod * method)
{
  struct GPtrArray * breakpoints.25;
  int D.22834;
  void * * D.22835;
  unsigned int i.26;
  unsigned int D.22837;
  void * * D.22838;
  struct MonoMethodDesc * D.22839;
  int D.22840;
  unsigned int D.22843;
  unsigned int i.27;
  unsigned int D.22845;
  int i;

  breakpoints.25 = breakpoints;
  if (breakpoints.25 == 0B) goto <D.22832>; else goto <D.22833>;
  <D.22832>:
  D.22834 = 0;
  return D.22834;
  <D.22833>:
  i = 0;
  goto <D.22367>;
  <D.22366>:
  {
    struct MiniDebugBreakpointInfo * info;

    breakpoints.25 = breakpoints;
    D.22835 = breakpoints.25->pdata;
    i.26 = (unsigned int) i;
    D.22837 = i.26 * 4;
    D.22838 = D.22835 + D.22837;
    info = *D.22838;
    D.22839 = info->desc;
    D.22840 = mono_method_desc_full_match (D.22839, method);
    if (D.22840 == 0) goto <D.22841>; else goto <D.22842>;
    <D.22841>:
    // predicted unlikely by continue predictor.
    goto <D.22365>;
    <D.22842>:
    D.22843 = info->index;
    D.22834 = (int) D.22843;
    return D.22834;
  }
  <D.22365>:
  i = i + 1;
  <D.22367>:
  i.27 = (unsigned int) i;
  breakpoints.25 = breakpoints;
  D.22845 = breakpoints.25->len;
  if (i.27 < D.22845) goto <D.22366>; else goto <D.22368>;
  <D.22368>:
  D.22834 = 0;
  return D.22834;
}