__attribute__((visibility ("hidden")))
mono_debug_init_method (struct MonoCompile * cfg, struct MonoBasicBlock * start_block, guint32 breakpoint_id)
{
  int D.22728;
  struct MiniDebugMethodInfo * info;

  D.22728 = mono_debug_enabled ();
  if (D.22728 == 0) goto <D.22729>; else goto <D.22730>;
  <D.22729>:
  return;
  <D.22730>:
  info = monoeg_malloc0 (24);
  info->breakpoint_id = breakpoint_id;
  cfg->debug_info = info;
}


__attribute__((visibility ("hidden")))
mono_debug_open_method (struct MonoCompile * cfg)
{
  struct MonoMethod * D.22734;
  struct MonoClass * D.22735;
  _Bool D.22736;
  long int D.22737;
  long int D.22738;
  struct GArray * D.22741;
  short unsigned int D.22742;
  unsigned int D.22743;
  unsigned int D.22744;
  long unsigned int D.22745;
  long unsigned int D.22746;
  void * D.22747;
  struct MiniDebugMethodInfo * info;
  struct MonoDebugMethodJitInfo * jit;
  struct MonoMethodHeader * header;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22732>; else goto <D.22733>;
  <D.22732>:
  return;
  <D.22733>:
  D.22734 = cfg->method;
  D.22735 = D.22734->klass;
  mono_class_init (D.22735);
  header = cfg->header;
  D.22736 = header == 0B;
  D.22737 = (long int) D.22736;
  D.22738 = __builtin_expect (D.22737, 0);
  if (D.22738 != 0) goto <D.22739>; else goto <D.22740>;
  <D.22739>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 77, "header");
  <D.22740>:
  jit = monoeg_malloc0 (104);
  info->jit = jit;
  D.22741 = monoeg_g_array_new (0, 1, 8);
  info->line_numbers = D.22741;
  D.22742 = header->num_locals;
  D.22743 = (unsigned int) D.22742;
  jit->num_locals = D.22743;
  D.22744 = jit->num_locals;
  D.22745 = (long unsigned int) D.22744;
  D.22746 = D.22745 * 32;
  D.22747 = monoeg_malloc0 (D.22746);
  jit->locals = D.22747;
}


__attribute__((visibility ("hidden")))
mono_debug_close_method (struct MonoCompile * cfg)
{
  struct MonoDebugMethodJitInfo * D.22752;
  unsigned char * D.22755;
  unsigned int D.22756;
  unsigned int D.22757;
  unsigned int D.22758;
  unsigned int D.22761;
  short unsigned int D.22762;
  unsigned int D.22763;
  unsigned int D.22764;
  long unsigned int D.22765;
  long unsigned int D.22766;
  void * D.22767;
  struct MonoInst * * D.22768;
  long unsigned int D.22769;
  long unsigned int D.22770;
  struct MonoInst * * D.22771;
  struct MonoInst * D.22772;
  struct MonoDebugVarInfo * D.22773;
  long unsigned int D.22774;
  struct MonoDebugVarInfo * D.22775;
  unsigned int D.22776;
  unsigned int i.0;
  long unsigned int D.22778;
  long unsigned int D.22779;
  void * D.22782;
  struct MonoInst * * D.22783;
  struct MonoInst * D.22784;
  struct MonoDebugVarInfo * D.22785;
  <unnamed-unsigned:1> D.22786;
  int D.22787;
  int D.22788;
  long unsigned int D.22789;
  long unsigned int D.22790;
  struct MonoInst * * D.22791;
  struct MonoInst * D.22792;
  struct MonoDebugVarInfo * D.22793;
  struct MonoDebugVarInfo * D.22794;
  struct MonoInst * D.22795;
  void * D.22798;
  void * D.22799;
  struct MonoDebugVarInfo * D.22800;
  struct MonoInst * D.22801;
  struct MonoDebugVarInfo * D.22802;
  struct GArray * D.22803;
  int D.22804;
  unsigned int D.22805;
  unsigned int D.22806;
  long unsigned int D.22807;
  long unsigned int D.22808;
  void * D.22809;
  struct MonoDebugLineNumberEntry * D.22810;
  struct MonoDebugLineNumberEntry * D.22811;
  gchar * D.22812;
  gchar * D.22813;
  struct MonoMethod * D.22814;
  struct MonoDomain * D.22815;
  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.22749>; else goto <D.22751>;
  <D.22751>:
  D.22752 = info->jit;
  if (D.22752 == 0B) goto <D.22749>; else goto <D.22750>;
  <D.22749>:
  if (info != 0B) goto <D.22753>; else goto <D.22754>;
  <D.22753>:
  monoeg_g_free (info);
  <D.22754>:
  return;
  <D.22750>:
  method = cfg->method;
  header = cfg->header;
  sig = mono_method_signature (method);
  jit = info->jit;
  D.22755 = cfg->native_code;
  jit->code_start = D.22755;
  D.22756 = cfg->epilog_begin;
  jit->epilogue_begin = D.22756;
  D.22757 = cfg->code_len;
  jit->code_size = D.22757;
  D.22758 = jit->epilogue_begin;
  if (D.22758 != 0) goto <D.22759>; else goto <D.22760>;
  <D.22759>:
  D.22758 = jit->epilogue_begin;
  D.22761 = header->code_size;
  record_line_number (info, D.22758, D.22761);
  <D.22760>:
  D.22762 = sig->param_count;
  D.22763 = (unsigned int) D.22762;
  jit->num_params = D.22763;
  D.22764 = jit->num_params;
  D.22765 = (long unsigned int) D.22764;
  D.22766 = D.22765 * 32;
  D.22767 = monoeg_malloc0 (D.22766);
  jit->params = D.22767;
  i = 0;
  goto <D.22556>;
  <D.22555>:
  D.22768 = cfg->locals;
  D.22769 = (long unsigned int) i;
  D.22770 = D.22769 * 8;
  D.22771 = D.22768 + D.22770;
  D.22772 = *D.22771;
  D.22773 = jit->locals;
  D.22769 = (long unsigned int) i;
  D.22774 = D.22769 * 32;
  D.22775 = D.22773 + D.22774;
  write_variable (D.22772, D.22775);
  i = i + 1;
  <D.22556>:
  D.22776 = jit->num_locals;
  i.0 = (unsigned int) i;
  if (D.22776 > i.0) goto <D.22555>; else goto <D.22557>;
  <D.22557>:
  D.22778 = BIT_FIELD_REF <*sig, 64, 64>;
  D.22779 = D.22778 & 512;
  if (D.22779 != 0) goto <D.22780>; else goto <D.22781>;
  <D.22780>:
  D.22782 = monoeg_malloc0 (32);
  jit->this_var = D.22782;
  D.22783 = cfg->args;
  D.22784 = *D.22783;
  D.22785 = jit->this_var;
  write_variable (D.22784, D.22785);
  <D.22781>:
  i = 0;
  goto <D.22559>;
  <D.22558>:
  D.22783 = cfg->args;
  D.22786 = sig->hasthis;
  D.22787 = (int) D.22786;
  D.22788 = D.22787 + i;
  D.22789 = (long unsigned int) D.22788;
  D.22790 = D.22789 * 8;
  D.22791 = D.22783 + D.22790;
  D.22792 = *D.22791;
  D.22793 = jit->params;
  D.22769 = (long unsigned int) i;
  D.22774 = D.22769 * 32;
  D.22794 = D.22793 + D.22774;
  write_variable (D.22792, D.22794);
  i = i + 1;
  <D.22559>:
  D.22764 = jit->num_params;
  i.0 = (unsigned int) i;
  if (D.22764 > i.0) goto <D.22558>; else goto <D.22560>;
  <D.22560>:
  D.22795 = cfg->gsharedvt_info_var;
  if (D.22795 != 0B) goto <D.22796>; else goto <D.22797>;
  <D.22796>:
  D.22798 = monoeg_malloc0 (32);
  jit->gsharedvt_info_var = D.22798;
  D.22799 = monoeg_malloc0 (32);
  jit->gsharedvt_locals_var = D.22799;
  D.22795 = cfg->gsharedvt_info_var;
  D.22800 = jit->gsharedvt_info_var;
  write_variable (D.22795, D.22800);
  D.22801 = cfg->gsharedvt_locals_var;
  D.22802 = jit->gsharedvt_locals_var;
  write_variable (D.22801, D.22802);
  <D.22797>:
  D.22803 = info->line_numbers;
  D.22804 = D.22803->len;
  D.22805 = (unsigned int) D.22804;
  jit->num_line_numbers = D.22805;
  D.22806 = jit->num_line_numbers;
  D.22807 = (long unsigned int) D.22806;
  D.22808 = D.22807 * 8;
  D.22809 = monoeg_malloc0 (D.22808);
  jit->line_numbers = D.22809;
  i = 0;
  goto <D.22562>;
  <D.22561>:
  D.22810 = jit->line_numbers;
  D.22769 = (long unsigned int) i;
  D.22770 = D.22769 * 8;
  D.22811 = D.22810 + D.22770;
  D.22803 = info->line_numbers;
  D.22812 = D.22803->data;
  D.22769 = (long unsigned int) i;
  D.22770 = D.22769 * 8;
  D.22813 = D.22812 + D.22770;
  *D.22811 = MEM[(struct MonoDebugLineNumberEntry *)D.22813];
  i = i + 1;
  <D.22562>:
  D.22806 = jit->num_line_numbers;
  i.0 = (unsigned int) i;
  if (D.22806 > i.0) goto <D.22561>; else goto <D.22563>;
  <D.22563>:
  D.22814 = cfg->method_to_register;
  D.22815 = cfg->domain;
  debug_info = mono_debug_add_method (D.22814, jit, D.22815);
  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.22817;
  struct MonoDebugLineNumberEntry lne;

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


write_variable (struct MonoInst * inst, struct MonoDebugVarInfo * var)
{
  struct MonoType * D.22818;
  short unsigned int D.22819;
  int D.22822;
  unsigned int D.22823;
  unsigned char D.22825;
  int D.22826;
  int D.22827;
  int D.22833;
  int D.22834;
  unsigned int D.22835;
  long int D.22836;
  unsigned int D.22837;
  int D.22841;
  unsigned int D.22842;
  long int D.22846;
  signed int D.22847;
  signed int D.22848;
  unsigned int D.22849;
  short unsigned int D.22853;
  _Bool D.22854;
  long int D.22855;
  long int D.22856;
  long int D.22859;
  unsigned int D.22860;
  int D.22861;
  int D.22862;
  unsigned int D.22863;

  D.22818 = inst->data.op[1].vtype;
  var->type = D.22818;
  D.22819 = inst->opcode;
  if (D.22819 == 366) goto <D.22820>; else goto <D.22821>;
  <D.22820>:
  D.22822 = inst->dreg;
  D.22823 = (unsigned int) D.22822;
  var->index = D.22823;
  goto <D.22824>;
  <D.22821>:
  D.22825 = inst->flags;
  D.22826 = (int) D.22825;
  D.22827 = D.22826 & 2;
  if (D.22827 != 0) goto <D.22828>; else goto <D.22829>;
  <D.22828>:
  var->index = 805306368;
  goto <D.22830>;
  <D.22829>:
  D.22819 = inst->opcode;
  if (D.22819 == 367) goto <D.22831>; else goto <D.22832>;
  <D.22831>:
  D.22833 = inst->sreg1;
  D.22834 = D.22833 | 268435456;
  D.22835 = (unsigned int) D.22834;
  var->index = D.22835;
  D.22836 = inst->data.op[0].const_val;
  D.22837 = (unsigned int) D.22836;
  var->offset = D.22837;
  goto <D.22838>;
  <D.22832>:
  D.22819 = inst->opcode;
  if (D.22819 == 332) goto <D.22839>; else goto <D.22840>;
  <D.22839>:
  D.22833 = inst->sreg1;
  D.22841 = D.22833 | 1073741824;
  D.22842 = (unsigned int) D.22841;
  var->index = D.22842;
  D.22836 = inst->data.op[0].const_val;
  D.22837 = (unsigned int) D.22836;
  var->offset = D.22837;
  goto <D.22843>;
  <D.22840>:
  D.22819 = inst->opcode;
  if (D.22819 == 331) goto <D.22844>; else goto <D.22845>;
  <D.22844>:
  D.22846 = inst->data.op[1].const_val;
  D.22847 = (signed int) D.22846;
  D.22848 = D.22847 | 1342177280;
  D.22849 = (unsigned int) D.22848;
  var->index = D.22849;
  goto <D.22850>;
  <D.22845>:
  D.22819 = inst->opcode;
  if (D.22819 == 368) goto <D.22851>; else goto <D.22852>;
  <D.22851>:
  {
    struct MonoInst * vtaddr;

    vtaddr = inst->data.op[0].src;
    D.22853 = vtaddr->opcode;
    D.22854 = D.22853 != 367;
    D.22855 = (long int) D.22854;
    D.22856 = __builtin_expect (D.22855, 0);
    if (D.22856 != 0) goto <D.22857>; else goto <D.22858>;
    <D.22857>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 107, "vtaddr->opcode == OP_REGOFFSET");
    <D.22858>:
    D.22859 = vtaddr->data.op[0].const_val;
    D.22860 = (unsigned int) D.22859;
    var->offset = D.22860;
    D.22861 = vtaddr->sreg1;
    D.22862 = D.22861 | 1610612736;
    D.22863 = (unsigned int) D.22862;
    var->index = D.22863;
  }
  goto <D.22864>;
  <D.22852>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 111);
  <D.22864>:
  <D.22850>:
  <D.22843>:
  <D.22838>:
  <D.22830>:
  <D.22824>:
}


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

}


__attribute__((visibility ("hidden")))
mono_debug_free_method (struct MonoCompile * cfg)
{
  struct GArray * D.22867;
  struct MiniDebugMethodInfo * info;

  info = cfg->debug_info;
  if (info != 0B) goto <D.22865>; else goto <D.22866>;
  <D.22865>:
  D.22867 = info->line_numbers;
  if (D.22867 != 0B) goto <D.22868>; else goto <D.22869>;
  <D.22868>:
  D.22867 = info->line_numbers;
  monoeg_g_array_free (D.22867, 1);
  <D.22869>:
  monoeg_g_free (info);
  cfg->debug_info = 0B;
  <D.22866>:
}


__attribute__((visibility ("hidden")))
mono_debug_record_line_number (struct MonoCompile * cfg, struct MonoInst * ins, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.22873;
  const unsigned char * D.22875;
  _Bool D.22876;
  long int D.22877;
  long int D.22878;
  const unsigned char * D.22883;
  unsigned int D.22885;
  sizetype D.22886;
  const unsigned char * D.22887;
  long int D.22888;
  long int D.22889;
  long int D.22890;
  unsigned int D.22891;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22870>; else goto <D.22872>;
  <D.22872>:
  D.22873 = info->jit;
  if (D.22873 == 0B) goto <D.22870>; else goto <D.22874>;
  <D.22874>:
  D.22875 = ins->cil_code;
  if (D.22875 == 0B) goto <D.22870>; else goto <D.22871>;
  <D.22870>:
  return;
  <D.22871>:
  header = cfg->header;
  D.22876 = header == 0B;
  D.22877 = (long int) D.22876;
  D.22878 = __builtin_expect (D.22877, 0);
  if (D.22878 != 0) goto <D.22879>; else goto <D.22880>;
  <D.22879>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 308, "header");
  <D.22880>:
  D.22875 = ins->cil_code;
  D.22883 = header->code;
  if (D.22875 < D.22883) goto <D.22881>; else goto <D.22884>;
  <D.22884>:
  D.22875 = ins->cil_code;
  D.22883 = header->code;
  D.22885 = header->code_size;
  D.22886 = (sizetype) D.22885;
  D.22887 = D.22883 + D.22886;
  if (D.22875 > D.22887) goto <D.22881>; else goto <D.22882>;
  <D.22881>:
  return;
  <D.22882>:
  D.22875 = ins->cil_code;
  D.22888 = (long int) D.22875;
  D.22883 = header->code;
  D.22889 = (long int) D.22883;
  D.22890 = D.22888 - D.22889;
  offset = (guint32) D.22890;
  D.22891 = info->has_line_numbers;
  if (D.22891 == 0) goto <D.22892>; else goto <D.22893>;
  <D.22892>:
  D.22873 = info->jit;
  D.22873->prologue_end = address;
  info->has_line_numbers = 1;
  <D.22893>:
  record_line_number (info, address, offset);
}


__attribute__((visibility ("hidden")))
mono_debug_open_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.22898;
  unsigned char * D.22900;
  _Bool D.22901;
  long int D.22902;
  long int D.22903;
  const unsigned char * D.22908;
  unsigned int D.22910;
  sizetype D.22911;
  const unsigned char * D.22912;
  long int D.22913;
  long int D.22914;
  long int D.22915;
  unsigned int D.22916;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22895>; else goto <D.22897>;
  <D.22897>:
  D.22898 = info->jit;
  if (D.22898 == 0B) goto <D.22895>; else goto <D.22899>;
  <D.22899>:
  D.22900 = bb->cil_code;
  if (D.22900 == 0B) goto <D.22895>; else goto <D.22896>;
  <D.22895>:
  return;
  <D.22896>:
  header = cfg->header;
  D.22901 = header == 0B;
  D.22902 = (long int) D.22901;
  D.22903 = __builtin_expect (D.22902, 0);
  if (D.22903 != 0) goto <D.22904>; else goto <D.22905>;
  <D.22904>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 335, "header");
  <D.22905>:
  D.22900 = bb->cil_code;
  D.22908 = header->code;
  if (D.22900 < D.22908) goto <D.22906>; else goto <D.22909>;
  <D.22909>:
  D.22900 = bb->cil_code;
  D.22908 = header->code;
  D.22910 = header->code_size;
  D.22911 = (sizetype) D.22910;
  D.22912 = D.22908 + D.22911;
  if (D.22900 > D.22912) goto <D.22906>; else goto <D.22907>;
  <D.22906>:
  return;
  <D.22907>:
  D.22900 = bb->cil_code;
  D.22913 = (long int) D.22900;
  D.22908 = header->code;
  D.22914 = (long int) D.22908;
  D.22915 = D.22913 - D.22914;
  offset = (guint32) D.22915;
  D.22916 = info->has_line_numbers;
  if (D.22916 == 0) goto <D.22917>; else goto <D.22918>;
  <D.22917>:
  D.22898 = info->jit;
  D.22898->prologue_end = address;
  info->has_line_numbers = 1;
  <D.22918>:
  record_line_number (info, address, offset);
}


__attribute__((visibility ("hidden")))
mono_debug_serialize_debug_info (struct MonoCompile * cfg, guint8 * * out_buf, guint32 * buf_len)
{
  struct MonoMethod * D.22920;
  struct MonoDomain * D.22921;
  unsigned int D.22924;
  unsigned int D.22925;
  unsigned int D.22926;
  unsigned int D.22927;
  unsigned int D.22928;
  unsigned int D.22929;
  unsigned int D.22930;
  long unsigned int D.22931;
  unsigned int D.22932;
  int D.22933;
  guint8 * p.1;
  unsigned int D.22935;
  int D.22936;
  unsigned int D.22937;
  int D.22938;
  struct MonoDebugVarInfo * D.22939;
  long unsigned int D.22940;
  long unsigned int D.22941;
  struct MonoDebugVarInfo * D.22942;
  unsigned int i.2;
  struct MonoMethodSignature * D.22944;
  long unsigned int D.22945;
  long unsigned int D.22946;
  struct MonoDebugVarInfo * D.22949;
  struct MonoDebugVarInfo * D.22950;
  struct MonoDebugVarInfo * D.22951;
  struct MonoDebugVarInfo * D.22952;
  struct MonoDebugVarInfo * D.22955;
  int D.22957;
  struct MonoDebugLineNumberEntry * D.22958;
  long unsigned int D.22959;
  unsigned int D.22960;
  unsigned int D.22961;
  int D.22962;
  unsigned int D.22963;
  unsigned int D.22964;
  int D.22965;
  long int p.3;
  long int buf.4;
  long int D.22968;
  long int D.22969;
  _Bool D.22970;
  long int D.22971;
  long int D.22972;
  unsigned int D.22975;
  struct MonoDebugMethodJitInfo * jit;
  guint32 size;
  guint32 prev_offset;
  guint32 prev_native_offset;
  guint8 * buf;
  guint8 * p;
  int i;

  try
    {
      D.22920 = cfg->method;
      D.22921 = mono_domain_get ();
      jit = mono_debug_find_method (D.22920, D.22921);
      if (jit == 0B) goto <D.22922>; else goto <D.22923>;
      <D.22922>:
      *buf_len = 0;
      return;
      <D.22923>:
      D.22924 = jit->num_params;
      D.22925 = jit->num_locals;
      D.22926 = D.22924 + D.22925;
      D.22927 = jit->num_line_numbers;
      D.22928 = D.22926 + D.22927;
      D.22929 = D.22928 + 1;
      D.22930 = D.22929 * 10;
      size = D.22930 + 64;
      D.22931 = (long unsigned int) size;
      buf = monoeg_malloc (D.22931);
      p = buf;
      D.22932 = jit->epilogue_begin;
      D.22933 = (int) D.22932;
      p.1 = p;
      encode_value (D.22933, p.1, &p);
      D.22935 = jit->prologue_end;
      D.22936 = (int) D.22935;
      p.1 = p;
      encode_value (D.22936, p.1, &p);
      D.22937 = jit->code_size;
      D.22938 = (int) D.22937;
      p.1 = p;
      encode_value (D.22938, p.1, &p);
      i = 0;
      goto <D.22623>;
      <D.22622>:
      D.22939 = jit->params;
      D.22940 = (long unsigned int) i;
      D.22941 = D.22940 * 32;
      D.22942 = D.22939 + D.22941;
      p.1 = p;
      serialize_variable (D.22942, p.1, &p);
      i = i + 1;
      <D.22623>:
      D.22924 = jit->num_params;
      i.2 = (unsigned int) i;
      if (D.22924 > i.2) goto <D.22622>; else goto <D.22624>;
      <D.22624>:
      D.22920 = cfg->method;
      D.22944 = mono_method_signature (D.22920);
      D.22945 = BIT_FIELD_REF <*D.22944, 64, 64>;
      D.22946 = D.22945 & 512;
      if (D.22946 != 0) goto <D.22947>; else goto <D.22948>;
      <D.22947>:
      D.22949 = jit->this_var;
      p.1 = p;
      serialize_variable (D.22949, p.1, &p);
      <D.22948>:
      i = 0;
      goto <D.22626>;
      <D.22625>:
      D.22950 = jit->locals;
      D.22940 = (long unsigned int) i;
      D.22941 = D.22940 * 32;
      D.22951 = D.22950 + D.22941;
      p.1 = p;
      serialize_variable (D.22951, p.1, &p);
      i = i + 1;
      <D.22626>:
      D.22925 = jit->num_locals;
      i.2 = (unsigned int) i;
      if (D.22925 > i.2) goto <D.22625>; else goto <D.22627>;
      <D.22627>:
      D.22952 = jit->gsharedvt_info_var;
      if (D.22952 != 0B) goto <D.22953>; else goto <D.22954>;
      <D.22953>:
      p.1 = p;
      encode_value (1, p.1, &p);
      D.22952 = jit->gsharedvt_info_var;
      p.1 = p;
      serialize_variable (D.22952, p.1, &p);
      D.22955 = jit->gsharedvt_locals_var;
      p.1 = p;
      serialize_variable (D.22955, p.1, &p);
      goto <D.22956>;
      <D.22954>:
      p.1 = p;
      encode_value (0, p.1, &p);
      <D.22956>:
      D.22927 = jit->num_line_numbers;
      D.22957 = (int) D.22927;
      p.1 = p;
      encode_value (D.22957, p.1, &p);
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22630>;
      <D.22629>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.22958 = jit->line_numbers;
        D.22940 = (long unsigned int) i;
        D.22959 = D.22940 * 8;
        lne = D.22958 + D.22959;
        D.22960 = lne->il_offset;
        D.22961 = D.22960 - prev_offset;
        D.22962 = (int) D.22961;
        p.1 = p;
        encode_value (D.22962, p.1, &p);
        D.22963 = lne->native_offset;
        D.22964 = D.22963 - prev_native_offset;
        D.22965 = (int) D.22964;
        p.1 = p;
        encode_value (D.22965, p.1, &p);
        prev_offset = lne->il_offset;
        prev_native_offset = lne->native_offset;
      }
      i = i + 1;
      <D.22630>:
      D.22927 = jit->num_line_numbers;
      i.2 = (unsigned int) i;
      if (D.22927 > i.2) goto <D.22629>; else goto <D.22631>;
      <D.22631>:
      p.1 = p;
      p.3 = (long int) p.1;
      buf.4 = (long int) buf;
      D.22968 = p.3 - buf.4;
      D.22969 = (long int) size;
      D.22970 = D.22968 >= D.22969;
      D.22971 = (long int) D.22970;
      D.22972 = __builtin_expect (D.22971, 0);
      if (D.22972 != 0) goto <D.22973>; else goto <D.22974>;
      <D.22973>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 491, "p - buf < size");
      <D.22974>:
      *out_buf = buf;
      p.1 = p;
      p.3 = (long int) p.1;
      buf.4 = (long int) buf;
      D.22968 = p.3 - buf.4;
      D.22975 = (unsigned int) D.22968;
      *buf_len = D.22975;
    }
  finally
    {
      p = {CLOBBER};
    }
}


serialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  unsigned int D.22979;
  int D.22980;
  guint8 * p.5;
  unsigned int D.22982;
  int D.22983;
  guint32 flags;

  D.22979 = var->index;
  flags = D.22979 & 4026531840;
  D.22979 = var->index;
  D.22980 = (int) D.22979;
  p.5 = p;
  encode_value (D.22980, p.5, &p);
  switch (flags) <default: <D.22609>, case 0: <D.22602>, case 268435456: <D.22604>, case 805306368: <D.22608>, case 1073741824: <D.22605>, case 1342177280: <D.22606>, case 1610612736: <D.22607>>
  <D.22602>:
  goto <D.22603>;
  <D.22604>:
  <D.22605>:
  D.22982 = var->offset;
  D.22983 = (int) D.22982;
  p.5 = p;
  encode_value (D.22983, p.5, &p);
  goto <D.22603>;
  <D.22606>:
  <D.22607>:
  <D.22608>:
  goto <D.22603>;
  <D.22609>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 435);
  <D.22603>:
  p.5 = p;
  *endbuf = p.5;
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.6;
  guint8 * p.7;
  unsigned char D.22989;
  int D.22993;
  signed char D.22994;
  signed char D.22995;
  unsigned char D.22996;
  guint8 * D.22997;
  int D.23001;
  signed char D.23002;
  signed char D.23003;
  unsigned char D.23004;
  int D.23005;
  unsigned char D.23006;
  guint8 * D.23007;
  unsigned char D.23008;
  guint8 * D.23009;
  unsigned int D.23011;
  unsigned char D.23012;
  guint8 * D.23013;
  guint8 * p;

  p = buf;
  value.6 = (unsigned int) value;
  if (value.6 <= 127) goto <D.22986>; else goto <D.22987>;
  <D.22986>:
  p.7 = p;
  p = p.7 + 1;
  D.22989 = (unsigned char) value;
  *p.7 = D.22989;
  goto <D.22990>;
  <D.22987>:
  value.6 = (unsigned int) value;
  if (value.6 <= 16383) goto <D.22991>; else goto <D.22992>;
  <D.22991>:
  D.22993 = value >> 8;
  D.22994 = (signed char) D.22993;
  D.22995 = D.22994 | -128;
  D.22996 = (unsigned char) D.22995;
  *p = D.22996;
  D.22997 = p + 1;
  D.22989 = (unsigned char) value;
  *D.22997 = D.22989;
  p = p + 2;
  goto <D.22998>;
  <D.22992>:
  value.6 = (unsigned int) value;
  if (value.6 <= 536870911) goto <D.22999>; else goto <D.23000>;
  <D.22999>:
  D.23001 = value >> 24;
  D.23002 = (signed char) D.23001;
  D.23003 = D.23002 | -64;
  D.23004 = (unsigned char) D.23003;
  *p = D.23004;
  D.22997 = p + 1;
  D.23005 = value >> 16;
  D.23006 = (unsigned char) D.23005;
  *D.22997 = D.23006;
  D.23007 = p + 2;
  D.22993 = value >> 8;
  D.23008 = (unsigned char) D.22993;
  *D.23007 = D.23008;
  D.23009 = p + 3;
  D.22989 = (unsigned char) value;
  *D.23009 = D.22989;
  p = p + 4;
  goto <D.23010>;
  <D.23000>:
  *p = 255;
  D.22997 = p + 1;
  value.6 = (unsigned int) value;
  D.23011 = value.6 >> 24;
  D.23012 = (unsigned char) D.23011;
  *D.22997 = D.23012;
  D.23007 = p + 2;
  D.23005 = value >> 16;
  D.23006 = (unsigned char) D.23005;
  *D.23007 = D.23006;
  D.23009 = p + 3;
  D.22993 = value >> 8;
  D.23008 = (unsigned char) D.22993;
  *D.23009 = D.23008;
  D.23013 = p + 4;
  D.22989 = (unsigned char) value;
  *D.23013 = D.22989;
  p = p + 5;
  <D.23010>:
  <D.22998>:
  <D.22990>:
  if (endbuf != 0B) goto <D.23014>; else goto <D.23015>;
  <D.23014>:
  *endbuf = p;
  <D.23015>:
}


__attribute__((visibility ("hidden")))
mono_debug_add_aot_method (struct MonoDomain * domain, struct MonoMethod * method, guint8 * code_start, guint8 * debug_info, guint32 debug_info_len)
{
  int D.23016;
  short unsigned int D.23021;
  unsigned int D.23022;
  unsigned int D.23023;
  short unsigned int D.23025;
  unsigned int D.23026;
  unsigned int D.23027;
  long unsigned int D.23029;
  long unsigned int D.23030;
  struct MonoDebugMethodJitInfo * jit;

  D.23016 = mono_debug_enabled ();
  if (D.23016 == 0) goto <D.23017>; else goto <D.23018>;
  <D.23017>:
  return;
  <D.23018>:
  D.23021 = method->iflags;
  D.23022 = (unsigned int) D.23021;
  D.23023 = D.23022 & 4099;
  if (D.23023 != 0) goto <D.23019>; else goto <D.23024>;
  <D.23024>:
  D.23025 = method->flags;
  D.23026 = (unsigned int) D.23025;
  D.23027 = D.23026 & 9216;
  if (D.23027 != 0) goto <D.23019>; else goto <D.23028>;
  <D.23028>:
  D.23029 = BIT_FIELD_REF <*method, 64, 256>;
  D.23030 = D.23029 & 4467570830351532032;
  if (D.23030 != 0) goto <D.23019>; else goto <D.23020>;
  <D.23019>:
  return;
  <D.23020>:
  if (debug_info_len == 0) goto <D.23031>; else goto <D.23032>;
  <D.23031>:
  return;
  <D.23032>:
  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.23034;
  long int D.23035;
  long int D.23036;
  short unsigned int D.23039;
  unsigned int D.23040;
  unsigned int D.23041;
  long unsigned int D.23042;
  long unsigned int D.23043;
  void * D.23044;
  struct MonoMethodSignature * D.23045;
  short unsigned int D.23046;
  unsigned int D.23047;
  unsigned int D.23048;
  long unsigned int D.23049;
  long unsigned int D.23050;
  void * D.23051;
  guint8 * p.8;
  int D.23053;
  unsigned int D.23054;
  int D.23055;
  unsigned int D.23056;
  int D.23057;
  unsigned int D.23058;
  struct MonoDebugVarInfo * D.23059;
  long unsigned int D.23060;
  long unsigned int D.23061;
  struct MonoDebugVarInfo * D.23062;
  unsigned int i.9;
  struct MonoMethodSignature * D.23064;
  long unsigned int D.23065;
  long unsigned int D.23066;
  void * D.23069;
  struct MonoDebugVarInfo * D.23070;
  struct MonoDebugVarInfo * D.23071;
  struct MonoDebugVarInfo * D.23072;
  int D.23073;
  void * D.23076;
  void * D.23077;
  struct MonoDebugVarInfo * D.23078;
  struct MonoDebugVarInfo * D.23079;
  int D.23080;
  unsigned int D.23081;
  unsigned int D.23082;
  long unsigned int D.23083;
  long unsigned int D.23084;
  void * D.23085;
  struct MonoDebugLineNumberEntry * D.23086;
  long unsigned int D.23087;
  int D.23088;
  int D.23089;
  unsigned int native_offset.10;
  unsigned int offset.11;
  struct MonoDebugMethodJitInfo * D.23092;
  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.23034 = header == 0B;
      D.23035 = (long int) D.23034;
      D.23036 = __builtin_expect (D.23035, 0);
      if (D.23036 != 0) goto <D.23037>; else goto <D.23038>;
      <D.23037>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 533, "header");
      <D.23038>:
      jit = monoeg_malloc0 (104);
      jit->code_start = code_start;
      D.23039 = header->num_locals;
      D.23040 = (unsigned int) D.23039;
      jit->num_locals = D.23040;
      D.23041 = jit->num_locals;
      D.23042 = (long unsigned int) D.23041;
      D.23043 = D.23042 * 32;
      D.23044 = monoeg_malloc0 (D.23043);
      jit->locals = D.23044;
      D.23045 = mono_method_signature (method);
      D.23046 = D.23045->param_count;
      D.23047 = (unsigned int) D.23046;
      jit->num_params = D.23047;
      D.23048 = jit->num_params;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 32;
      D.23051 = monoeg_malloc0 (D.23050);
      jit->params = D.23051;
      p = buf;
      p.8 = p;
      D.23053 = decode_value (p.8, &p);
      D.23054 = (unsigned int) D.23053;
      jit->epilogue_begin = D.23054;
      p.8 = p;
      D.23055 = decode_value (p.8, &p);
      D.23056 = (unsigned int) D.23055;
      jit->prologue_end = D.23056;
      p.8 = p;
      D.23057 = decode_value (p.8, &p);
      D.23058 = (unsigned int) D.23057;
      jit->code_size = D.23058;
      i = 0;
      goto <D.22661>;
      <D.22660>:
      D.23059 = jit->params;
      D.23060 = (long unsigned int) i;
      D.23061 = D.23060 * 32;
      D.23062 = D.23059 + D.23061;
      p.8 = p;
      deserialize_variable (D.23062, p.8, &p);
      i = i + 1;
      <D.22661>:
      D.23048 = jit->num_params;
      i.9 = (unsigned int) i;
      if (D.23048 > i.9) goto <D.22660>; else goto <D.22662>;
      <D.22662>:
      D.23064 = mono_method_signature (method);
      D.23065 = BIT_FIELD_REF <*D.23064, 64, 64>;
      D.23066 = D.23065 & 512;
      if (D.23066 != 0) goto <D.23067>; else goto <D.23068>;
      <D.23067>:
      D.23069 = monoeg_malloc0 (32);
      jit->this_var = D.23069;
      D.23070 = jit->this_var;
      p.8 = p;
      deserialize_variable (D.23070, p.8, &p);
      <D.23068>:
      i = 0;
      goto <D.22664>;
      <D.22663>:
      D.23071 = jit->locals;
      D.23060 = (long unsigned int) i;
      D.23061 = D.23060 * 32;
      D.23072 = D.23071 + D.23061;
      p.8 = p;
      deserialize_variable (D.23072, p.8, &p);
      i = i + 1;
      <D.22664>:
      D.23041 = jit->num_locals;
      i.9 = (unsigned int) i;
      if (D.23041 > i.9) goto <D.22663>; else goto <D.22665>;
      <D.22665>:
      p.8 = p;
      D.23073 = decode_value (p.8, &p);
      if (D.23073 != 0) goto <D.23074>; else goto <D.23075>;
      <D.23074>:
      D.23076 = monoeg_malloc0 (32);
      jit->gsharedvt_info_var = D.23076;
      D.23077 = monoeg_malloc0 (32);
      jit->gsharedvt_locals_var = D.23077;
      D.23078 = jit->gsharedvt_info_var;
      p.8 = p;
      deserialize_variable (D.23078, p.8, &p);
      D.23079 = jit->gsharedvt_locals_var;
      p.8 = p;
      deserialize_variable (D.23079, p.8, &p);
      <D.23075>:
      p.8 = p;
      D.23080 = decode_value (p.8, &p);
      D.23081 = (unsigned int) D.23080;
      jit->num_line_numbers = D.23081;
      D.23082 = jit->num_line_numbers;
      D.23083 = (long unsigned int) D.23082;
      D.23084 = D.23083 * 8;
      D.23085 = monoeg_malloc0 (D.23084);
      jit->line_numbers = D.23085;
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22668>;
      <D.22667>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.23086 = jit->line_numbers;
        D.23060 = (long unsigned int) i;
        D.23087 = D.23060 * 8;
        lne = D.23086 + D.23087;
        p.8 = p;
        D.23088 = decode_value (p.8, &p);
        offset = D.23088 + prev_offset;
        p.8 = p;
        D.23089 = decode_value (p.8, &p);
        native_offset = D.23089 + prev_native_offset;
        native_offset.10 = (unsigned int) native_offset;
        lne->native_offset = native_offset.10;
        offset.11 = (unsigned int) offset;
        lne->il_offset = offset.11;
        prev_offset = offset;
        prev_native_offset = native_offset;
      }
      i = i + 1;
      <D.22668>:
      D.23082 = jit->num_line_numbers;
      i.9 = (unsigned int) i;
      if (D.23082 > i.9) goto <D.22667>; else goto <D.22669>;
      <D.22669>:
      mono_metadata_free_mh (header);
      D.23092 = jit;
      return D.23092;
    }
  finally
    {
      p = {CLOBBER};
    }
}


deserialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  guint8 * p.12;
  int D.23096;
  unsigned int D.23097;
  unsigned int D.23098;
  int D.23099;
  unsigned int D.23100;
  guint32 flags;

  p.12 = p;
  D.23096 = decode_value (p.12, &p);
  D.23097 = (unsigned int) D.23096;
  var->index = D.23097;
  D.23098 = var->index;
  flags = D.23098 & 4026531840;
  switch (flags) <default: <D.22645>, case 0: <D.22638>, case 268435456: <D.22640>, case 805306368: <D.22644>, case 1073741824: <D.22641>, case 1342177280: <D.22642>, case 1610612736: <D.22643>>
  <D.22638>:
  goto <D.22639>;
  <D.22640>:
  <D.22641>:
  p.12 = p;
  D.23099 = decode_value (p.12, &p);
  D.23100 = (unsigned int) D.23099;
  var->offset = D.23100;
  goto <D.22639>;
  <D.22642>:
  <D.22643>:
  <D.22644>:
  goto <D.22639>;
  <D.22645>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 518);
  <D.22639>:
  p.12 = p;
  *endbuf = p.12;
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.13;
  int D.23106;
  int D.23107;
  int D.23110;
  int D.23111;
  guint8 * D.23112;
  unsigned char D.23113;
  int D.23114;
  int D.23118;
  int D.23119;
  int D.23120;
  int D.23121;
  guint8 * D.23122;
  unsigned char D.23123;
  int D.23124;
  int D.23125;
  int D.23126;
  guint8 * D.23127;
  unsigned char D.23128;
  int D.23129;
  int D.23131;
  int D.23132;
  int D.23133;
  int D.23134;
  int D.23135;
  guint8 * D.23136;
  unsigned char D.23137;
  int D.23138;
  gint32 D.23141;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.13 = (signed char) b;
  if (b.13 >= 0) goto <D.23103>; else goto <D.23104>;
  <D.23103>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.23105>;
  <D.23104>:
  D.23106 = (int) b;
  D.23107 = D.23106 & 64;
  if (D.23107 == 0) goto <D.23108>; else goto <D.23109>;
  <D.23108>:
  D.23106 = (int) b;
  D.23110 = D.23106 << 8;
  D.23111 = D.23110 & 16128;
  D.23112 = ptr + 1;
  D.23113 = *D.23112;
  D.23114 = (int) D.23113;
  len = D.23111 | D.23114;
  ptr = ptr + 2;
  goto <D.23115>;
  <D.23109>:
  if (b != 255) goto <D.23116>; else goto <D.23117>;
  <D.23116>:
  D.23106 = (int) b;
  D.23118 = D.23106 << 24;
  D.23119 = D.23118 & 520093696;
  D.23112 = ptr + 1;
  D.23113 = *D.23112;
  D.23114 = (int) D.23113;
  D.23120 = D.23114 << 16;
  D.23121 = D.23119 | D.23120;
  D.23122 = ptr + 2;
  D.23123 = *D.23122;
  D.23124 = (int) D.23123;
  D.23125 = D.23124 << 8;
  D.23126 = D.23121 | D.23125;
  D.23127 = ptr + 3;
  D.23128 = *D.23127;
  D.23129 = (int) D.23128;
  len = D.23126 | D.23129;
  ptr = ptr + 4;
  goto <D.23130>;
  <D.23117>:
  D.23112 = ptr + 1;
  D.23113 = *D.23112;
  D.23114 = (int) D.23113;
  D.23131 = D.23114 << 24;
  D.23122 = ptr + 2;
  D.23123 = *D.23122;
  D.23124 = (int) D.23123;
  D.23132 = D.23124 << 16;
  D.23133 = D.23131 | D.23132;
  D.23127 = ptr + 3;
  D.23128 = *D.23127;
  D.23129 = (int) D.23128;
  D.23134 = D.23129 << 8;
  D.23135 = D.23133 | D.23134;
  D.23136 = ptr + 4;
  D.23137 = *D.23136;
  D.23138 = (int) D.23137;
  len = D.23135 | D.23138;
  ptr = ptr + 5;
  <D.23130>:
  <D.23115>:
  <D.23105>:
  if (rptr != 0B) goto <D.23139>; else goto <D.23140>;
  <D.23139>:
  *rptr = ptr;
  <D.23140>:
  D.23141 = len;
  return D.23141;
}


mono_debug_print_vars (void * ip, gboolean only_arguments)
{
  struct MonoMethod * D.23145;
  unsigned int D.23150;
  long unsigned int D.23151;
  long unsigned int D.23152;
  struct MonoMethod * D.23153;
  struct MonoDebugVarInfo * D.23154;
  struct MonoDebugVarInfo * D.23157;
  long unsigned int D.23158;
  long unsigned int D.23159;
  struct MonoDebugVarInfo * D.23160;
  const char * iftmp.14;
  long unsigned int D.23162;
  char * * D.23163;
  char * D.23164;
  unsigned int i.15;
  struct MonoDebugVarInfo * D.23170;
  struct MonoDebugVarInfo * D.23171;
  unsigned int D.23172;
  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.23143>; else goto <D.23144>;
  <D.23143>:
  return;
  <D.23144>:
  D.23145 = jinfo_get_method (ji);
  jit = mono_debug_find_method (D.23145, domain);
  if (jit == 0B) goto <D.23146>; else goto <D.23147>;
  <D.23146>:
  return;
  <D.23147>:
  if (only_arguments != 0) goto <D.23148>; else goto <D.23149>;
  <D.23148>:
  {
    char * * names;

    D.23150 = jit->num_params;
    D.23151 = (long unsigned int) D.23150;
    D.23152 = D.23151 * 8;
    names = monoeg_malloc (D.23152);
    D.23153 = jinfo_get_method (ji);
    mono_method_get_param_names (D.23153, names);
    D.23154 = jit->this_var;
    if (D.23154 != 0B) goto <D.23155>; else goto <D.23156>;
    <D.23155>:
    D.23154 = jit->this_var;
    print_var_info (D.23154, 0, "this", "Arg");
    <D.23156>:
    i = 0;
    goto <D.22702>;
    <D.22701>:
    D.23157 = jit->params;
    D.23158 = (long unsigned int) i;
    D.23159 = D.23158 * 32;
    D.23160 = D.23157 + D.23159;
    D.23158 = (long unsigned int) i;
    D.23162 = D.23158 * 8;
    D.23163 = names + D.23162;
    D.23164 = *D.23163;
    if (D.23164 != 0B) goto <D.23165>; else goto <D.23166>;
    <D.23165>:
    D.23158 = (long unsigned int) i;
    D.23162 = D.23158 * 8;
    D.23163 = names + D.23162;
    iftmp.14 = *D.23163;
    goto <D.23167>;
    <D.23166>:
    iftmp.14 = "unknown name";
    <D.23167>:
    print_var_info (D.23160, i, iftmp.14, "Arg");
    i = i + 1;
    <D.22702>:
    D.23150 = jit->num_params;
    i.15 = (unsigned int) i;
    if (D.23150 > i.15) goto <D.22701>; else goto <D.22703>;
    <D.22703>:
    monoeg_g_free (names);
  }
  goto <D.23169>;
  <D.23149>:
  i = 0;
  goto <D.22705>;
  <D.22704>:
  D.23170 = jit->locals;
  D.23158 = (long unsigned int) i;
  D.23159 = D.23158 * 32;
  D.23171 = D.23170 + D.23159;
  print_var_info (D.23171, i, "", "Local");
  i = i + 1;
  <D.22705>:
  D.23172 = jit->num_locals;
  i.15 = (unsigned int) i;
  if (D.23172 > i.15) goto <D.22704>; else goto <D.22706>;
  <D.22706>:
  <D.23169>:
  mono_debug_free_method_jit_info (jit);
}


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

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


print_var_info (struct MonoDebugVarInfo * info, int idx, const char * name, const char * type)
{
  unsigned int D.23176;
  unsigned int D.23177;
  int D.23178;
  int D.23179;
  const char * D.23180;
  const char * D.23181;
  unsigned int D.23182;
  const char * D.23183;
  const char * D.23184;

  D.23176 = info->index;
  D.23177 = D.23176 & 4026531840;
  switch (D.23177) <default: <D.22691>, case 0: <D.22684>, case 268435456: <D.22686>, case 536870912: <D.22690>, case 1073741824: <D.22687>, case 1342177280: <D.22688>, case 1610612736: <D.22689>>
  <D.22684>:
  D.23176 = info->index;
  D.23178 = (int) D.23176;
  D.23179 = D.23178 & 268435455;
  D.23180 = mono_arch_regname (D.23179);
  monoeg_g_print ("%s %s (%d) in register %s\n", type, name, idx, D.23180);
  goto <D.22685>;
  <D.22686>:
  D.23176 = info->index;
  D.23178 = (int) D.23176;
  D.23179 = D.23178 & 268435455;
  D.23181 = mono_arch_regname (D.23179);
  D.23182 = info->offset;
  monoeg_g_print ("%s %s (%d) in memory: base register %s + %d\n", type, name, idx, D.23181, D.23182);
  goto <D.22685>;
  <D.22687>:
  D.23176 = info->index;
  D.23178 = (int) D.23176;
  D.23179 = D.23178 & 268435455;
  D.23183 = mono_arch_regname (D.23179);
  D.23182 = info->offset;
  monoeg_g_print ("%s %s (%d) in indir memory: base register %s + %d\n", type, name, idx, D.23183, D.23182);
  goto <D.22685>;
  <D.22688>:
  monoeg_g_print ("%s %s (%d) gsharedvt local.\n", type, name, idx);
  goto <D.22685>;
  <D.22689>:
  D.23176 = info->index;
  D.23178 = (int) D.23176;
  D.23179 = D.23178 & 268435455;
  D.23184 = mono_arch_regname (D.23179);
  D.23182 = info->offset;
  monoeg_g_print ("%s %s (%d) vt address: base register %s + %d\n", type, name, idx, D.23184, D.23182);
  goto <D.22685>;
  <D.22690>:
  <D.22691>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 636);
  <D.22685>:
}


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

  desc = mono_method_desc_new (method_name, include_namespace);
  if (desc == 0B) goto <D.23185>; else goto <D.23186>;
  <D.23185>:
  D.23187 = 0;
  return D.23187;
  <D.23186>:
  D.23187 = mono_debugger_insert_breakpoint_full (desc);
  return D.23187;
}


mono_debugger_insert_breakpoint_full (struct MonoMethodDesc * desc)
{
  int last_breakpoint_id.16;
  int last_breakpoint_id.17;
  unsigned int last_breakpoint_id.18;
  struct GPtrArray * breakpoints.19;
  struct GPtrArray * D.23195;
  int D.23196;
  unsigned int D.23197;
  static int last_breakpoint_id = 0;
  struct MiniDebugBreakpointInfo * info;

  info = monoeg_malloc0 (16);
  info->desc = desc;
  last_breakpoint_id.16 = last_breakpoint_id;
  last_breakpoint_id.17 = last_breakpoint_id.16 + 1;
  last_breakpoint_id = last_breakpoint_id.17;
  last_breakpoint_id.16 = last_breakpoint_id;
  last_breakpoint_id.18 = (unsigned int) last_breakpoint_id.16;
  info->index = last_breakpoint_id.18;
  breakpoints.19 = breakpoints;
  if (breakpoints.19 == 0B) goto <D.23193>; else goto <D.23194>;
  <D.23193>:
  D.23195 = monoeg_g_ptr_array_new ();
  breakpoints = D.23195;
  <D.23194>:
  breakpoints.19 = breakpoints;
  monoeg_g_ptr_array_add (breakpoints.19, info);
  D.23197 = info->index;
  D.23196 = (int) D.23197;
  return D.23196;
}


mono_debugger_method_has_breakpoint (struct MonoMethod * method)
{
  struct GPtrArray * breakpoints.20;
  int D.23202;
  void * * D.23203;
  long unsigned int D.23204;
  long unsigned int D.23205;
  void * * D.23206;
  struct MonoMethodDesc * D.23207;
  int D.23208;
  unsigned int D.23211;
  unsigned int D.23212;
  unsigned int i.21;
  int i;

  breakpoints.20 = breakpoints;
  if (breakpoints.20 == 0B) goto <D.23200>; else goto <D.23201>;
  <D.23200>:
  D.23202 = 0;
  return D.23202;
  <D.23201>:
  i = 0;
  goto <D.22725>;
  <D.22724>:
  {
    struct MiniDebugBreakpointInfo * info;

    breakpoints.20 = breakpoints;
    D.23203 = breakpoints.20->pdata;
    D.23204 = (long unsigned int) i;
    D.23205 = D.23204 * 8;
    D.23206 = D.23203 + D.23205;
    info = *D.23206;
    D.23207 = info->desc;
    D.23208 = mono_method_desc_full_match (D.23207, method);
    if (D.23208 == 0) goto <D.23209>; else goto <D.23210>;
    <D.23209>:
    // predicted unlikely by continue predictor.
    goto <D.22723>;
    <D.23210>:
    D.23211 = info->index;
    D.23202 = (int) D.23211;
    return D.23202;
  }
  <D.22723>:
  i = i + 1;
  <D.22725>:
  breakpoints.20 = breakpoints;
  D.23212 = breakpoints.20->len;
  i.21 = (unsigned int) i;
  if (D.23212 > i.21) goto <D.22724>; else goto <D.22726>;
  <D.22726>:
  D.23202 = 0;
  return D.23202;
}