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

  D.22808 = mono_debug_enabled ();
  if (D.22808 == 0) goto <D.22809>; else goto <D.22810>;
  <D.22809>:
  return;
  <D.22810>:
  info = monoeg_malloc0 (24);
  info->breakpoint_id = breakpoint_id;
  cfg->debug_info = info;
}


mono_debug_open_method (struct MonoCompile * cfg)
{
  struct MonoMethod * D.22814;
  struct MonoClass * D.22815;
  _Bool D.22816;
  long int D.22817;
  long int D.22818;
  struct GArray * D.22821;
  short unsigned int D.22822;
  unsigned int D.22823;
  unsigned int D.22824;
  long unsigned int D.22825;
  long unsigned int D.22826;
  void * D.22827;
  struct MiniDebugMethodInfo * info;
  struct MonoDebugMethodJitInfo * jit;
  struct MonoMethodHeader * header;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22812>; else goto <D.22813>;
  <D.22812>:
  return;
  <D.22813>:
  D.22814 = cfg->method;
  D.22815 = D.22814->klass;
  mono_class_init (D.22815);
  header = cfg->header;
  D.22816 = header == 0B;
  D.22817 = (long int) D.22816;
  D.22818 = __builtin_expect (D.22817, 0);
  if (D.22818 != 0) goto <D.22819>; else goto <D.22820>;
  <D.22819>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 77, "header");
  <D.22820>:
  jit = monoeg_malloc0 (104);
  info->jit = jit;
  D.22821 = monoeg_g_array_new (0, 1, 8);
  info->line_numbers = D.22821;
  D.22822 = header->num_locals;
  D.22823 = (unsigned int) D.22822;
  jit->num_locals = D.22823;
  D.22824 = jit->num_locals;
  D.22825 = (long unsigned int) D.22824;
  D.22826 = D.22825 * 32;
  D.22827 = monoeg_malloc0 (D.22826);
  jit->locals = D.22827;
}


mono_debug_close_method (struct MonoCompile * cfg)
{
  struct MonoDebugMethodJitInfo * D.22832;
  unsigned char * D.22835;
  unsigned int D.22836;
  unsigned int D.22837;
  unsigned int D.22838;
  unsigned int D.22841;
  short unsigned int D.22842;
  unsigned int D.22843;
  unsigned int D.22844;
  long unsigned int D.22845;
  long unsigned int D.22846;
  void * D.22847;
  struct MonoDebugVarInfo * D.22848;
  long unsigned int D.22849;
  long unsigned int D.22850;
  struct MonoDebugVarInfo * D.22851;
  struct MonoInst * * D.22852;
  long unsigned int D.22853;
  struct MonoInst * * D.22854;
  struct MonoInst * D.22855;
  unsigned int i.0;
  unsigned int D.22857;
  unsigned char D.22858;
  unsigned char D.22859;
  void * D.22862;
  struct MonoDebugVarInfo * D.22863;
  struct MonoInst * * D.22864;
  struct MonoInst * D.22865;
  struct MonoDebugVarInfo * D.22866;
  struct MonoDebugVarInfo * D.22867;
  <unnamed-unsigned:1> D.22868;
  int D.22869;
  int D.22870;
  long unsigned int D.22871;
  long unsigned int D.22872;
  struct MonoInst * * D.22873;
  struct MonoInst * D.22874;
  struct MonoInst * D.22875;
  void * D.22878;
  void * D.22879;
  struct MonoDebugVarInfo * D.22880;
  struct MonoDebugVarInfo * D.22881;
  struct MonoInst * D.22882;
  struct GArray * D.22883;
  int D.22884;
  unsigned int D.22885;
  unsigned int D.22886;
  long unsigned int D.22887;
  long unsigned int D.22888;
  void * D.22889;
  struct MonoDebugLineNumberEntry * D.22890;
  struct MonoDebugLineNumberEntry * D.22891;
  gchar * D.22892;
  struct MonoDebugLineNumberEntry * D.22893;
  struct MonoDomain * D.22894;
  struct MonoMethod * D.22895;
  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.22829>; else goto <D.22831>;
  <D.22831>:
  D.22832 = info->jit;
  if (D.22832 == 0B) goto <D.22829>; else goto <D.22830>;
  <D.22829>:
  if (info != 0B) goto <D.22833>; else goto <D.22834>;
  <D.22833>:
  monoeg_g_free (info);
  <D.22834>:
  return;
  <D.22830>:
  method = cfg->method;
  header = cfg->header;
  sig = mono_method_signature (method);
  jit = info->jit;
  D.22835 = cfg->native_code;
  jit->code_start = D.22835;
  D.22836 = cfg->epilog_begin;
  jit->epilogue_begin = D.22836;
  D.22837 = cfg->code_len;
  jit->code_size = D.22837;
  D.22838 = jit->epilogue_begin;
  if (D.22838 != 0) goto <D.22839>; else goto <D.22840>;
  <D.22839>:
  D.22841 = header->code_size;
  D.22838 = jit->epilogue_begin;
  record_line_number (info, D.22838, D.22841);
  <D.22840>:
  D.22842 = sig->param_count;
  D.22843 = (unsigned int) D.22842;
  jit->num_params = D.22843;
  D.22844 = jit->num_params;
  D.22845 = (long unsigned int) D.22844;
  D.22846 = D.22845 * 32;
  D.22847 = monoeg_malloc0 (D.22846);
  jit->params = D.22847;
  i = 0;
  goto <D.22636>;
  <D.22635>:
  D.22848 = jit->locals;
  D.22849 = (long unsigned int) i;
  D.22850 = D.22849 * 32;
  D.22851 = D.22848 + D.22850;
  D.22852 = cfg->locals;
  D.22849 = (long unsigned int) i;
  D.22853 = D.22849 * 8;
  D.22854 = D.22852 + D.22853;
  D.22855 = *D.22854;
  write_variable (D.22855, D.22851);
  i = i + 1;
  <D.22636>:
  i.0 = (unsigned int) i;
  D.22857 = jit->num_locals;
  if (i.0 < D.22857) goto <D.22635>; else goto <D.22637>;
  <D.22637>:
  D.22858 = BIT_FIELD_REF <*sig, 8, 112>;
  D.22859 = D.22858 & 64;
  if (D.22859 != 0) goto <D.22860>; else goto <D.22861>;
  <D.22860>:
  D.22862 = monoeg_malloc0 (32);
  jit->this_var = D.22862;
  D.22863 = jit->this_var;
  D.22864 = cfg->args;
  D.22865 = *D.22864;
  write_variable (D.22865, D.22863);
  <D.22861>:
  i = 0;
  goto <D.22639>;
  <D.22638>:
  D.22866 = jit->params;
  D.22849 = (long unsigned int) i;
  D.22850 = D.22849 * 32;
  D.22867 = D.22866 + D.22850;
  D.22864 = cfg->args;
  D.22868 = sig->hasthis;
  D.22869 = (int) D.22868;
  D.22870 = D.22869 + i;
  D.22871 = (long unsigned int) D.22870;
  D.22872 = D.22871 * 8;
  D.22873 = D.22864 + D.22872;
  D.22874 = *D.22873;
  write_variable (D.22874, D.22867);
  i = i + 1;
  <D.22639>:
  i.0 = (unsigned int) i;
  D.22844 = jit->num_params;
  if (i.0 < D.22844) goto <D.22638>; else goto <D.22640>;
  <D.22640>:
  D.22875 = cfg->gsharedvt_info_var;
  if (D.22875 != 0B) goto <D.22876>; else goto <D.22877>;
  <D.22876>:
  D.22878 = monoeg_malloc0 (32);
  jit->gsharedvt_info_var = D.22878;
  D.22879 = monoeg_malloc0 (32);
  jit->gsharedvt_locals_var = D.22879;
  D.22880 = jit->gsharedvt_info_var;
  D.22875 = cfg->gsharedvt_info_var;
  write_variable (D.22875, D.22880);
  D.22881 = jit->gsharedvt_locals_var;
  D.22882 = cfg->gsharedvt_locals_var;
  write_variable (D.22882, D.22881);
  <D.22877>:
  D.22883 = info->line_numbers;
  D.22884 = D.22883->len;
  D.22885 = (unsigned int) D.22884;
  jit->num_line_numbers = D.22885;
  D.22886 = jit->num_line_numbers;
  D.22887 = (long unsigned int) D.22886;
  D.22888 = D.22887 * 8;
  D.22889 = monoeg_malloc0 (D.22888);
  jit->line_numbers = D.22889;
  i = 0;
  goto <D.22642>;
  <D.22641>:
  D.22890 = jit->line_numbers;
  D.22849 = (long unsigned int) i;
  D.22853 = D.22849 * 8;
  D.22891 = D.22890 + D.22853;
  D.22883 = info->line_numbers;
  D.22892 = D.22883->data;
  D.22849 = (long unsigned int) i;
  D.22853 = D.22849 * 8;
  D.22893 = D.22892 + D.22853;
  *D.22891 = *D.22893;
  i = i + 1;
  <D.22642>:
  i.0 = (unsigned int) i;
  D.22886 = jit->num_line_numbers;
  if (i.0 < D.22886) goto <D.22641>; else goto <D.22643>;
  <D.22643>:
  D.22894 = cfg->domain;
  D.22895 = cfg->method_to_register;
  debug_info = mono_debug_add_method (D.22895, jit, D.22894);
  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.22897;
  struct MonoDebugLineNumberEntry lne;

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


write_variable (struct MonoInst * inst, struct MonoDebugVarInfo * var)
{
  struct MonoType * D.22898;
  short unsigned int D.22899;
  int D.22902;
  unsigned int D.22903;
  unsigned char D.22905;
  int D.22906;
  int D.22907;
  int D.22913;
  int D.22914;
  unsigned int D.22915;
  long int D.22916;
  unsigned int D.22917;
  int D.22921;
  unsigned int D.22922;
  long int D.22926;
  signed int D.22927;
  signed int D.22928;
  unsigned int D.22929;
  short unsigned int D.22933;
  _Bool D.22934;
  long int D.22935;
  long int D.22936;
  long int D.22939;
  unsigned int D.22940;
  int D.22941;
  int D.22942;
  unsigned int D.22943;

  D.22898 = inst->data.op[1].vtype;
  var->type = D.22898;
  D.22899 = inst->opcode;
  if (D.22899 == 366) goto <D.22900>; else goto <D.22901>;
  <D.22900>:
  D.22902 = inst->dreg;
  D.22903 = (unsigned int) D.22902;
  var->index = D.22903;
  goto <D.22904>;
  <D.22901>:
  D.22905 = inst->flags;
  D.22906 = (int) D.22905;
  D.22907 = D.22906 & 2;
  if (D.22907 != 0) goto <D.22908>; else goto <D.22909>;
  <D.22908>:
  var->index = 805306368;
  goto <D.22910>;
  <D.22909>:
  D.22899 = inst->opcode;
  if (D.22899 == 367) goto <D.22911>; else goto <D.22912>;
  <D.22911>:
  D.22913 = inst->sreg1;
  D.22914 = D.22913 | 268435456;
  D.22915 = (unsigned int) D.22914;
  var->index = D.22915;
  D.22916 = inst->data.op[0].const_val;
  D.22917 = (unsigned int) D.22916;
  var->offset = D.22917;
  goto <D.22918>;
  <D.22912>:
  D.22899 = inst->opcode;
  if (D.22899 == 332) goto <D.22919>; else goto <D.22920>;
  <D.22919>:
  D.22913 = inst->sreg1;
  D.22921 = D.22913 | 1073741824;
  D.22922 = (unsigned int) D.22921;
  var->index = D.22922;
  D.22916 = inst->data.op[0].const_val;
  D.22917 = (unsigned int) D.22916;
  var->offset = D.22917;
  goto <D.22923>;
  <D.22920>:
  D.22899 = inst->opcode;
  if (D.22899 == 331) goto <D.22924>; else goto <D.22925>;
  <D.22924>:
  D.22926 = inst->data.op[1].const_val;
  D.22927 = (signed int) D.22926;
  D.22928 = D.22927 | 1342177280;
  D.22929 = (unsigned int) D.22928;
  var->index = D.22929;
  goto <D.22930>;
  <D.22925>:
  D.22899 = inst->opcode;
  if (D.22899 == 368) goto <D.22931>; else goto <D.22932>;
  <D.22931>:
  {
    struct MonoInst * vtaddr;

    vtaddr = inst->data.op[0].src;
    D.22933 = vtaddr->opcode;
    D.22934 = D.22933 != 367;
    D.22935 = (long int) D.22934;
    D.22936 = __builtin_expect (D.22935, 0);
    if (D.22936 != 0) goto <D.22937>; else goto <D.22938>;
    <D.22937>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 107, "vtaddr->opcode == OP_REGOFFSET");
    <D.22938>:
    D.22939 = vtaddr->data.op[0].const_val;
    D.22940 = (unsigned int) D.22939;
    var->offset = D.22940;
    D.22941 = vtaddr->sreg1;
    D.22942 = D.22941 | 1610612736;
    D.22943 = (unsigned int) D.22942;
    var->index = D.22943;
  }
  goto <D.22944>;
  <D.22932>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 111);
  <D.22944>:
  <D.22930>:
  <D.22923>:
  <D.22918>:
  <D.22910>:
  <D.22904>:
}


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

}


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

  info = cfg->debug_info;
  if (info != 0B) goto <D.22945>; else goto <D.22946>;
  <D.22945>:
  D.22947 = info->line_numbers;
  if (D.22947 != 0B) goto <D.22948>; else goto <D.22949>;
  <D.22948>:
  D.22947 = info->line_numbers;
  monoeg_g_array_free (D.22947, 1);
  <D.22949>:
  monoeg_g_free (info);
  cfg->debug_info = 0B;
  <D.22946>:
}


mono_debug_record_line_number (struct MonoCompile * cfg, struct MonoInst * ins, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.22953;
  const unsigned char * D.22955;
  _Bool D.22956;
  long int D.22957;
  long int D.22958;
  const unsigned char * D.22963;
  unsigned int D.22965;
  sizetype D.22966;
  const unsigned char * D.22967;
  long int D.22968;
  long int D.22969;
  long int D.22970;
  unsigned int D.22971;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22950>; else goto <D.22952>;
  <D.22952>:
  D.22953 = info->jit;
  if (D.22953 == 0B) goto <D.22950>; else goto <D.22954>;
  <D.22954>:
  D.22955 = ins->cil_code;
  if (D.22955 == 0B) goto <D.22950>; else goto <D.22951>;
  <D.22950>:
  return;
  <D.22951>:
  header = cfg->header;
  D.22956 = header == 0B;
  D.22957 = (long int) D.22956;
  D.22958 = __builtin_expect (D.22957, 0);
  if (D.22958 != 0) goto <D.22959>; else goto <D.22960>;
  <D.22959>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 308, "header");
  <D.22960>:
  D.22955 = ins->cil_code;
  D.22963 = header->code;
  if (D.22955 < D.22963) goto <D.22961>; else goto <D.22964>;
  <D.22964>:
  D.22955 = ins->cil_code;
  D.22963 = header->code;
  D.22965 = header->code_size;
  D.22966 = (sizetype) D.22965;
  D.22967 = D.22963 + D.22966;
  if (D.22955 > D.22967) goto <D.22961>; else goto <D.22962>;
  <D.22961>:
  return;
  <D.22962>:
  D.22955 = ins->cil_code;
  D.22968 = (long int) D.22955;
  D.22963 = header->code;
  D.22969 = (long int) D.22963;
  D.22970 = D.22968 - D.22969;
  offset = (guint32) D.22970;
  D.22971 = info->has_line_numbers;
  if (D.22971 == 0) goto <D.22972>; else goto <D.22973>;
  <D.22972>:
  D.22953 = info->jit;
  D.22953->prologue_end = address;
  info->has_line_numbers = 1;
  <D.22973>:
  record_line_number (info, address, offset);
}


mono_debug_open_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.22978;
  unsigned char * D.22980;
  _Bool D.22981;
  long int D.22982;
  long int D.22983;
  const unsigned char * D.22988;
  unsigned int D.22990;
  sizetype D.22991;
  const unsigned char * D.22992;
  long int D.22993;
  long int D.22994;
  long int D.22995;
  unsigned int D.22996;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22975>; else goto <D.22977>;
  <D.22977>:
  D.22978 = info->jit;
  if (D.22978 == 0B) goto <D.22975>; else goto <D.22979>;
  <D.22979>:
  D.22980 = bb->cil_code;
  if (D.22980 == 0B) goto <D.22975>; else goto <D.22976>;
  <D.22975>:
  return;
  <D.22976>:
  header = cfg->header;
  D.22981 = header == 0B;
  D.22982 = (long int) D.22981;
  D.22983 = __builtin_expect (D.22982, 0);
  if (D.22983 != 0) goto <D.22984>; else goto <D.22985>;
  <D.22984>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 335, "header");
  <D.22985>:
  D.22980 = bb->cil_code;
  D.22988 = header->code;
  if (D.22980 < D.22988) goto <D.22986>; else goto <D.22989>;
  <D.22989>:
  D.22980 = bb->cil_code;
  D.22988 = header->code;
  D.22990 = header->code_size;
  D.22991 = (sizetype) D.22990;
  D.22992 = D.22988 + D.22991;
  if (D.22980 > D.22992) goto <D.22986>; else goto <D.22987>;
  <D.22986>:
  return;
  <D.22987>:
  D.22980 = bb->cil_code;
  D.22993 = (long int) D.22980;
  D.22988 = header->code;
  D.22994 = (long int) D.22988;
  D.22995 = D.22993 - D.22994;
  offset = (guint32) D.22995;
  D.22996 = info->has_line_numbers;
  if (D.22996 == 0) goto <D.22997>; else goto <D.22998>;
  <D.22997>:
  D.22978 = info->jit;
  D.22978->prologue_end = address;
  info->has_line_numbers = 1;
  <D.22998>:
  record_line_number (info, address, offset);
}


mono_debug_serialize_debug_info (struct MonoCompile * cfg, guint8 * * out_buf, guint32 * buf_len)
{
  struct MonoDomain * D.23000;
  struct MonoMethod * D.23001;
  unsigned int D.23004;
  unsigned int D.23005;
  unsigned int D.23006;
  unsigned int D.23007;
  unsigned int D.23008;
  unsigned int D.23009;
  unsigned int D.23010;
  long unsigned int D.23011;
  guint8 * p.1;
  unsigned int D.23013;
  int D.23014;
  unsigned int D.23015;
  int D.23016;
  unsigned int D.23017;
  int D.23018;
  struct MonoDebugVarInfo * D.23019;
  long unsigned int D.23020;
  long unsigned int D.23021;
  struct MonoDebugVarInfo * D.23022;
  unsigned int i.2;
  struct MonoMethodSignature * D.23024;
  unsigned char D.23025;
  unsigned char D.23026;
  struct MonoDebugVarInfo * D.23029;
  struct MonoDebugVarInfo * D.23030;
  struct MonoDebugVarInfo * D.23031;
  struct MonoDebugVarInfo * D.23032;
  struct MonoDebugVarInfo * D.23035;
  int D.23037;
  struct MonoDebugLineNumberEntry * D.23038;
  long unsigned int D.23039;
  unsigned int D.23040;
  unsigned int D.23041;
  int D.23042;
  unsigned int D.23043;
  unsigned int D.23044;
  int D.23045;
  long int p.3;
  long int buf.4;
  long int D.23048;
  long int D.23049;
  _Bool D.23050;
  long int D.23051;
  long int D.23052;
  unsigned int D.23055;
  struct MonoDebugMethodJitInfo * jit;
  guint32 size;
  guint32 prev_offset;
  guint32 prev_native_offset;
  guint8 * buf;
  guint8 * p;
  int i;

  try
    {
      D.23000 = mono_domain_get ();
      D.23001 = cfg->method;
      jit = mono_debug_find_method (D.23001, D.23000);
      if (jit == 0B) goto <D.23002>; else goto <D.23003>;
      <D.23002>:
      *buf_len = 0;
      return;
      <D.23003>:
      D.23004 = jit->num_params;
      D.23005 = jit->num_locals;
      D.23006 = D.23004 + D.23005;
      D.23007 = jit->num_line_numbers;
      D.23008 = D.23006 + D.23007;
      D.23009 = D.23008 + 1;
      D.23010 = D.23009 * 10;
      size = D.23010 + 64;
      D.23011 = (long unsigned int) size;
      buf = monoeg_malloc (D.23011);
      p = buf;
      p.1 = p;
      D.23013 = jit->epilogue_begin;
      D.23014 = (int) D.23013;
      encode_value (D.23014, p.1, &p);
      p.1 = p;
      D.23015 = jit->prologue_end;
      D.23016 = (int) D.23015;
      encode_value (D.23016, p.1, &p);
      p.1 = p;
      D.23017 = jit->code_size;
      D.23018 = (int) D.23017;
      encode_value (D.23018, p.1, &p);
      i = 0;
      goto <D.22703>;
      <D.22702>:
      p.1 = p;
      D.23019 = jit->params;
      D.23020 = (long unsigned int) i;
      D.23021 = D.23020 * 32;
      D.23022 = D.23019 + D.23021;
      serialize_variable (D.23022, p.1, &p);
      i = i + 1;
      <D.22703>:
      i.2 = (unsigned int) i;
      D.23004 = jit->num_params;
      if (i.2 < D.23004) goto <D.22702>; else goto <D.22704>;
      <D.22704>:
      D.23001 = cfg->method;
      D.23024 = mono_method_signature (D.23001);
      D.23025 = BIT_FIELD_REF <*D.23024, 8, 112>;
      D.23026 = D.23025 & 64;
      if (D.23026 != 0) goto <D.23027>; else goto <D.23028>;
      <D.23027>:
      p.1 = p;
      D.23029 = jit->this_var;
      serialize_variable (D.23029, p.1, &p);
      <D.23028>:
      i = 0;
      goto <D.22706>;
      <D.22705>:
      p.1 = p;
      D.23030 = jit->locals;
      D.23020 = (long unsigned int) i;
      D.23021 = D.23020 * 32;
      D.23031 = D.23030 + D.23021;
      serialize_variable (D.23031, p.1, &p);
      i = i + 1;
      <D.22706>:
      i.2 = (unsigned int) i;
      D.23005 = jit->num_locals;
      if (i.2 < D.23005) goto <D.22705>; else goto <D.22707>;
      <D.22707>:
      D.23032 = jit->gsharedvt_info_var;
      if (D.23032 != 0B) goto <D.23033>; else goto <D.23034>;
      <D.23033>:
      p.1 = p;
      encode_value (1, p.1, &p);
      p.1 = p;
      D.23032 = jit->gsharedvt_info_var;
      serialize_variable (D.23032, p.1, &p);
      p.1 = p;
      D.23035 = jit->gsharedvt_locals_var;
      serialize_variable (D.23035, p.1, &p);
      goto <D.23036>;
      <D.23034>:
      p.1 = p;
      encode_value (0, p.1, &p);
      <D.23036>:
      p.1 = p;
      D.23007 = jit->num_line_numbers;
      D.23037 = (int) D.23007;
      encode_value (D.23037, p.1, &p);
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22710>;
      <D.22709>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.23038 = jit->line_numbers;
        D.23020 = (long unsigned int) i;
        D.23039 = D.23020 * 8;
        lne = D.23038 + D.23039;
        p.1 = p;
        D.23040 = lne->il_offset;
        D.23041 = D.23040 - prev_offset;
        D.23042 = (int) D.23041;
        encode_value (D.23042, p.1, &p);
        p.1 = p;
        D.23043 = lne->native_offset;
        D.23044 = D.23043 - prev_native_offset;
        D.23045 = (int) D.23044;
        encode_value (D.23045, p.1, &p);
        prev_offset = lne->il_offset;
        prev_native_offset = lne->native_offset;
      }
      i = i + 1;
      <D.22710>:
      i.2 = (unsigned int) i;
      D.23007 = jit->num_line_numbers;
      if (i.2 < D.23007) goto <D.22709>; else goto <D.22711>;
      <D.22711>:
      p.1 = p;
      p.3 = (long int) p.1;
      buf.4 = (long int) buf;
      D.23048 = p.3 - buf.4;
      D.23049 = (long int) size;
      D.23050 = D.23048 >= D.23049;
      D.23051 = (long int) D.23050;
      D.23052 = __builtin_expect (D.23051, 0);
      if (D.23052 != 0) goto <D.23053>; else goto <D.23054>;
      <D.23053>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 491, "p - buf < size");
      <D.23054>:
      *out_buf = buf;
      p.1 = p;
      p.3 = (long int) p.1;
      buf.4 = (long int) buf;
      D.23048 = p.3 - buf.4;
      D.23055 = (unsigned int) D.23048;
      *buf_len = D.23055;
    }
  finally
    {
      p = {CLOBBER};
    }
}


serialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  unsigned int D.23059;
  guint8 * p.5;
  int D.23061;
  unsigned int D.23062;
  int D.23063;
  guint32 flags;

  D.23059 = var->index;
  flags = D.23059 & 4026531840;
  p.5 = p;
  D.23059 = var->index;
  D.23061 = (int) D.23059;
  encode_value (D.23061, p.5, &p);
  switch (flags) <default: <D.22689>, case 0: <D.22682>, case 268435456: <D.22684>, case 805306368: <D.22688>, case 1073741824: <D.22685>, case 1342177280: <D.22686>, case 1610612736: <D.22687>>
  <D.22682>:
  goto <D.22683>;
  <D.22684>:
  <D.22685>:
  p.5 = p;
  D.23062 = var->offset;
  D.23063 = (int) D.23062;
  encode_value (D.23063, p.5, &p);
  goto <D.22683>;
  <D.22686>:
  <D.22687>:
  <D.22688>:
  goto <D.22683>;
  <D.22689>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 435);
  <D.22683>:
  p.5 = p;
  *endbuf = p.5;
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.6;
  guint8 * p.7;
  unsigned char D.23069;
  int D.23073;
  signed char D.23074;
  signed char D.23075;
  unsigned char D.23076;
  guint8 * D.23077;
  unsigned char D.23078;
  int D.23082;
  signed char D.23083;
  signed char D.23084;
  unsigned char D.23085;
  int D.23086;
  unsigned char D.23087;
  guint8 * D.23088;
  unsigned char D.23089;
  guint8 * D.23090;
  unsigned int D.23092;
  unsigned char D.23093;
  guint8 * D.23094;
  guint8 * p;

  p = buf;
  value.6 = (unsigned int) value;
  if (value.6 <= 127) goto <D.23066>; else goto <D.23067>;
  <D.23066>:
  p.7 = p;
  p = p.7 + 1;
  D.23069 = (unsigned char) value;
  *p.7 = D.23069;
  goto <D.23070>;
  <D.23067>:
  value.6 = (unsigned int) value;
  if (value.6 <= 16383) goto <D.23071>; else goto <D.23072>;
  <D.23071>:
  D.23073 = value >> 8;
  D.23074 = (signed char) D.23073;
  D.23075 = D.23074 | -128;
  D.23076 = (unsigned char) D.23075;
  *p = D.23076;
  D.23077 = p + 1;
  D.23078 = (unsigned char) value;
  *D.23077 = D.23078;
  p = p + 2;
  goto <D.23079>;
  <D.23072>:
  value.6 = (unsigned int) value;
  if (value.6 <= 536870911) goto <D.23080>; else goto <D.23081>;
  <D.23080>:
  D.23082 = value >> 24;
  D.23083 = (signed char) D.23082;
  D.23084 = D.23083 | -64;
  D.23085 = (unsigned char) D.23084;
  *p = D.23085;
  D.23077 = p + 1;
  D.23086 = value >> 16;
  D.23087 = (unsigned char) D.23086;
  *D.23077 = D.23087;
  D.23088 = p + 2;
  D.23073 = value >> 8;
  D.23089 = (unsigned char) D.23073;
  *D.23088 = D.23089;
  D.23090 = p + 3;
  D.23078 = (unsigned char) value;
  *D.23090 = D.23078;
  p = p + 4;
  goto <D.23091>;
  <D.23081>:
  *p = 255;
  D.23077 = p + 1;
  value.6 = (unsigned int) value;
  D.23092 = value.6 >> 24;
  D.23093 = (unsigned char) D.23092;
  *D.23077 = D.23093;
  D.23088 = p + 2;
  D.23086 = value >> 16;
  D.23087 = (unsigned char) D.23086;
  *D.23088 = D.23087;
  D.23090 = p + 3;
  D.23073 = value >> 8;
  D.23089 = (unsigned char) D.23073;
  *D.23090 = D.23089;
  D.23094 = p + 4;
  D.23078 = (unsigned char) value;
  *D.23094 = D.23078;
  p = p + 5;
  <D.23091>:
  <D.23079>:
  <D.23070>:
  if (endbuf != 0B) goto <D.23095>; else goto <D.23096>;
  <D.23095>:
  *endbuf = p;
  <D.23096>:
}


mono_debug_add_aot_method (struct MonoDomain * domain, struct MonoMethod * method, guint8 * code_start, guint8 * debug_info, guint32 debug_info_len)
{
  int D.23097;
  short unsigned int D.23102;
  unsigned int D.23103;
  unsigned int D.23104;
  short unsigned int D.23106;
  unsigned int D.23107;
  unsigned int D.23108;
  unsigned char D.23110;
  unsigned char D.23111;
  struct MonoDebugMethodJitInfo * jit;

  D.23097 = mono_debug_enabled ();
  if (D.23097 == 0) goto <D.23098>; else goto <D.23099>;
  <D.23098>:
  return;
  <D.23099>:
  D.23102 = method->iflags;
  D.23103 = (unsigned int) D.23102;
  D.23104 = D.23103 & 4099;
  if (D.23104 != 0) goto <D.23100>; else goto <D.23105>;
  <D.23105>:
  D.23106 = method->flags;
  D.23107 = (unsigned int) D.23106;
  D.23108 = D.23107 & 9216;
  if (D.23108 != 0) goto <D.23100>; else goto <D.23109>;
  <D.23109>:
  D.23110 = BIT_FIELD_REF <*method, 8, 256>;
  D.23111 = D.23110 & 124;
  if (D.23111 != 0) goto <D.23100>; else goto <D.23101>;
  <D.23100>:
  return;
  <D.23101>:
  if (debug_info_len == 0) goto <D.23112>; else goto <D.23113>;
  <D.23112>:
  return;
  <D.23113>:
  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.23115;
  long int D.23116;
  long int D.23117;
  short unsigned int D.23120;
  unsigned int D.23121;
  unsigned int D.23122;
  long unsigned int D.23123;
  long unsigned int D.23124;
  void * D.23125;
  struct MonoMethodSignature * D.23126;
  short unsigned int D.23127;
  unsigned int D.23128;
  unsigned int D.23129;
  long unsigned int D.23130;
  long unsigned int D.23131;
  void * D.23132;
  guint8 * p.8;
  int D.23134;
  unsigned int D.23135;
  int D.23136;
  unsigned int D.23137;
  int D.23138;
  unsigned int D.23139;
  struct MonoDebugVarInfo * D.23140;
  long unsigned int D.23141;
  long unsigned int D.23142;
  struct MonoDebugVarInfo * D.23143;
  unsigned int i.9;
  struct MonoMethodSignature * D.23145;
  unsigned char D.23146;
  unsigned char D.23147;
  void * D.23150;
  struct MonoDebugVarInfo * D.23151;
  struct MonoDebugVarInfo * D.23152;
  struct MonoDebugVarInfo * D.23153;
  int D.23154;
  void * D.23157;
  void * D.23158;
  struct MonoDebugVarInfo * D.23159;
  struct MonoDebugVarInfo * D.23160;
  int D.23161;
  unsigned int D.23162;
  unsigned int D.23163;
  long unsigned int D.23164;
  long unsigned int D.23165;
  void * D.23166;
  struct MonoDebugLineNumberEntry * D.23167;
  long unsigned int D.23168;
  int D.23169;
  int D.23170;
  unsigned int native_offset.10;
  unsigned int offset.11;
  struct MonoDebugMethodJitInfo * D.23173;
  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.23115 = header == 0B;
      D.23116 = (long int) D.23115;
      D.23117 = __builtin_expect (D.23116, 0);
      if (D.23117 != 0) goto <D.23118>; else goto <D.23119>;
      <D.23118>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 533, "header");
      <D.23119>:
      jit = monoeg_malloc0 (104);
      jit->code_start = code_start;
      D.23120 = header->num_locals;
      D.23121 = (unsigned int) D.23120;
      jit->num_locals = D.23121;
      D.23122 = jit->num_locals;
      D.23123 = (long unsigned int) D.23122;
      D.23124 = D.23123 * 32;
      D.23125 = monoeg_malloc0 (D.23124);
      jit->locals = D.23125;
      D.23126 = mono_method_signature (method);
      D.23127 = D.23126->param_count;
      D.23128 = (unsigned int) D.23127;
      jit->num_params = D.23128;
      D.23129 = jit->num_params;
      D.23130 = (long unsigned int) D.23129;
      D.23131 = D.23130 * 32;
      D.23132 = monoeg_malloc0 (D.23131);
      jit->params = D.23132;
      p = buf;
      p.8 = p;
      D.23134 = decode_value (p.8, &p);
      D.23135 = (unsigned int) D.23134;
      jit->epilogue_begin = D.23135;
      p.8 = p;
      D.23136 = decode_value (p.8, &p);
      D.23137 = (unsigned int) D.23136;
      jit->prologue_end = D.23137;
      p.8 = p;
      D.23138 = decode_value (p.8, &p);
      D.23139 = (unsigned int) D.23138;
      jit->code_size = D.23139;
      i = 0;
      goto <D.22741>;
      <D.22740>:
      p.8 = p;
      D.23140 = jit->params;
      D.23141 = (long unsigned int) i;
      D.23142 = D.23141 * 32;
      D.23143 = D.23140 + D.23142;
      deserialize_variable (D.23143, p.8, &p);
      i = i + 1;
      <D.22741>:
      i.9 = (unsigned int) i;
      D.23129 = jit->num_params;
      if (i.9 < D.23129) goto <D.22740>; else goto <D.22742>;
      <D.22742>:
      D.23145 = mono_method_signature (method);
      D.23146 = BIT_FIELD_REF <*D.23145, 8, 112>;
      D.23147 = D.23146 & 64;
      if (D.23147 != 0) goto <D.23148>; else goto <D.23149>;
      <D.23148>:
      D.23150 = monoeg_malloc0 (32);
      jit->this_var = D.23150;
      p.8 = p;
      D.23151 = jit->this_var;
      deserialize_variable (D.23151, p.8, &p);
      <D.23149>:
      i = 0;
      goto <D.22744>;
      <D.22743>:
      p.8 = p;
      D.23152 = jit->locals;
      D.23141 = (long unsigned int) i;
      D.23142 = D.23141 * 32;
      D.23153 = D.23152 + D.23142;
      deserialize_variable (D.23153, p.8, &p);
      i = i + 1;
      <D.22744>:
      i.9 = (unsigned int) i;
      D.23122 = jit->num_locals;
      if (i.9 < D.23122) goto <D.22743>; else goto <D.22745>;
      <D.22745>:
      p.8 = p;
      D.23154 = decode_value (p.8, &p);
      if (D.23154 != 0) goto <D.23155>; else goto <D.23156>;
      <D.23155>:
      D.23157 = monoeg_malloc0 (32);
      jit->gsharedvt_info_var = D.23157;
      D.23158 = monoeg_malloc0 (32);
      jit->gsharedvt_locals_var = D.23158;
      p.8 = p;
      D.23159 = jit->gsharedvt_info_var;
      deserialize_variable (D.23159, p.8, &p);
      p.8 = p;
      D.23160 = jit->gsharedvt_locals_var;
      deserialize_variable (D.23160, p.8, &p);
      <D.23156>:
      p.8 = p;
      D.23161 = decode_value (p.8, &p);
      D.23162 = (unsigned int) D.23161;
      jit->num_line_numbers = D.23162;
      D.23163 = jit->num_line_numbers;
      D.23164 = (long unsigned int) D.23163;
      D.23165 = D.23164 * 8;
      D.23166 = monoeg_malloc0 (D.23165);
      jit->line_numbers = D.23166;
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22748>;
      <D.22747>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.23167 = jit->line_numbers;
        D.23141 = (long unsigned int) i;
        D.23168 = D.23141 * 8;
        lne = D.23167 + D.23168;
        p.8 = p;
        D.23169 = decode_value (p.8, &p);
        offset = D.23169 + prev_offset;
        p.8 = p;
        D.23170 = decode_value (p.8, &p);
        native_offset = D.23170 + 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.22748>:
      i.9 = (unsigned int) i;
      D.23163 = jit->num_line_numbers;
      if (i.9 < D.23163) goto <D.22747>; else goto <D.22749>;
      <D.22749>:
      mono_metadata_free_mh (header);
      D.23173 = jit;
      return D.23173;
    }
  finally
    {
      p = {CLOBBER};
    }
}


deserialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  guint8 * p.12;
  int D.23177;
  unsigned int D.23178;
  unsigned int D.23179;
  int D.23180;
  unsigned int D.23181;
  guint32 flags;

  p.12 = p;
  D.23177 = decode_value (p.12, &p);
  D.23178 = (unsigned int) D.23177;
  var->index = D.23178;
  D.23179 = var->index;
  flags = D.23179 & 4026531840;
  switch (flags) <default: <D.22725>, case 0: <D.22718>, case 268435456: <D.22720>, case 805306368: <D.22724>, case 1073741824: <D.22721>, case 1342177280: <D.22722>, case 1610612736: <D.22723>>
  <D.22718>:
  goto <D.22719>;
  <D.22720>:
  <D.22721>:
  p.12 = p;
  D.23180 = decode_value (p.12, &p);
  D.23181 = (unsigned int) D.23180;
  var->offset = D.23181;
  goto <D.22719>;
  <D.22722>:
  <D.22723>:
  <D.22724>:
  goto <D.22719>;
  <D.22725>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 518);
  <D.22719>:
  p.12 = p;
  *endbuf = p.12;
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.13;
  int D.23187;
  int D.23188;
  int D.23191;
  int D.23192;
  guint8 * D.23193;
  unsigned char D.23194;
  int D.23195;
  int D.23199;
  int D.23200;
  int D.23201;
  int D.23202;
  guint8 * D.23203;
  unsigned char D.23204;
  int D.23205;
  int D.23206;
  int D.23207;
  guint8 * D.23208;
  unsigned char D.23209;
  int D.23210;
  int D.23212;
  int D.23213;
  int D.23214;
  int D.23215;
  int D.23216;
  guint8 * D.23217;
  unsigned char D.23218;
  int D.23219;
  gint32 D.23222;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.13 = (signed char) b;
  if (b.13 >= 0) goto <D.23184>; else goto <D.23185>;
  <D.23184>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.23186>;
  <D.23185>:
  D.23187 = (int) b;
  D.23188 = D.23187 & 64;
  if (D.23188 == 0) goto <D.23189>; else goto <D.23190>;
  <D.23189>:
  D.23187 = (int) b;
  D.23191 = D.23187 & 63;
  D.23192 = D.23191 << 8;
  D.23193 = ptr + 1;
  D.23194 = *D.23193;
  D.23195 = (int) D.23194;
  len = D.23192 | D.23195;
  ptr = ptr + 2;
  goto <D.23196>;
  <D.23190>:
  if (b != 255) goto <D.23197>; else goto <D.23198>;
  <D.23197>:
  D.23187 = (int) b;
  D.23199 = D.23187 & 31;
  D.23200 = D.23199 << 24;
  D.23193 = ptr + 1;
  D.23194 = *D.23193;
  D.23195 = (int) D.23194;
  D.23201 = D.23195 << 16;
  D.23202 = D.23200 | D.23201;
  D.23203 = ptr + 2;
  D.23204 = *D.23203;
  D.23205 = (int) D.23204;
  D.23206 = D.23205 << 8;
  D.23207 = D.23202 | D.23206;
  D.23208 = ptr + 3;
  D.23209 = *D.23208;
  D.23210 = (int) D.23209;
  len = D.23207 | D.23210;
  ptr = ptr + 4;
  goto <D.23211>;
  <D.23198>:
  D.23193 = ptr + 1;
  D.23194 = *D.23193;
  D.23195 = (int) D.23194;
  D.23212 = D.23195 << 24;
  D.23203 = ptr + 2;
  D.23204 = *D.23203;
  D.23205 = (int) D.23204;
  D.23213 = D.23205 << 16;
  D.23214 = D.23212 | D.23213;
  D.23208 = ptr + 3;
  D.23209 = *D.23208;
  D.23210 = (int) D.23209;
  D.23215 = D.23210 << 8;
  D.23216 = D.23214 | D.23215;
  D.23217 = ptr + 4;
  D.23218 = *D.23217;
  D.23219 = (int) D.23218;
  len = D.23216 | D.23219;
  ptr = ptr + 5;
  <D.23211>:
  <D.23196>:
  <D.23186>:
  if (rptr != 0B) goto <D.23220>; else goto <D.23221>;
  <D.23220>:
  *rptr = ptr;
  <D.23221>:
  D.23222 = len;
  return D.23222;
}


mono_debug_print_vars (void * ip, gboolean only_arguments)
{
  struct MonoMethod * D.23226;
  unsigned int D.23231;
  long unsigned int D.23232;
  long unsigned int D.23233;
  struct MonoMethod * D.23234;
  struct MonoDebugVarInfo * D.23235;
  const char * iftmp.14;
  long unsigned int D.23239;
  long unsigned int D.23240;
  char * * D.23241;
  char * D.23242;
  struct MonoDebugVarInfo * D.23246;
  long unsigned int D.23247;
  struct MonoDebugVarInfo * D.23248;
  unsigned int i.15;
  struct MonoDebugVarInfo * D.23251;
  struct MonoDebugVarInfo * D.23252;
  unsigned int D.23253;
  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.23224>; else goto <D.23225>;
  <D.23224>:
  return;
  <D.23225>:
  D.23226 = jinfo_get_method (ji);
  jit = mono_debug_find_method (D.23226, domain);
  if (jit == 0B) goto <D.23227>; else goto <D.23228>;
  <D.23227>:
  return;
  <D.23228>:
  if (only_arguments != 0) goto <D.23229>; else goto <D.23230>;
  <D.23229>:
  {
    char * * names;

    D.23231 = jit->num_params;
    D.23232 = (long unsigned int) D.23231;
    D.23233 = D.23232 * 8;
    names = monoeg_malloc (D.23233);
    D.23234 = jinfo_get_method (ji);
    mono_method_get_param_names (D.23234, names);
    D.23235 = jit->this_var;
    if (D.23235 != 0B) goto <D.23236>; else goto <D.23237>;
    <D.23236>:
    D.23235 = jit->this_var;
    print_var_info (D.23235, 0, "this", "Arg");
    <D.23237>:
    i = 0;
    goto <D.22782>;
    <D.22781>:
    D.23239 = (long unsigned int) i;
    D.23240 = D.23239 * 8;
    D.23241 = names + D.23240;
    D.23242 = *D.23241;
    if (D.23242 != 0B) goto <D.23243>; else goto <D.23244>;
    <D.23243>:
    D.23239 = (long unsigned int) i;
    D.23240 = D.23239 * 8;
    D.23241 = names + D.23240;
    iftmp.14 = *D.23241;
    goto <D.23245>;
    <D.23244>:
    iftmp.14 = "unknown name";
    <D.23245>:
    D.23246 = jit->params;
    D.23239 = (long unsigned int) i;
    D.23247 = D.23239 * 32;
    D.23248 = D.23246 + D.23247;
    print_var_info (D.23248, i, iftmp.14, "Arg");
    i = i + 1;
    <D.22782>:
    i.15 = (unsigned int) i;
    D.23231 = jit->num_params;
    if (i.15 < D.23231) goto <D.22781>; else goto <D.22783>;
    <D.22783>:
    monoeg_g_free (names);
  }
  goto <D.23250>;
  <D.23230>:
  i = 0;
  goto <D.22785>;
  <D.22784>:
  D.23251 = jit->locals;
  D.23239 = (long unsigned int) i;
  D.23247 = D.23239 * 32;
  D.23252 = D.23251 + D.23247;
  print_var_info (D.23252, i, "", "Local");
  i = i + 1;
  <D.22785>:
  i.15 = (unsigned int) i;
  D.23253 = jit->num_locals;
  if (i.15 < D.23253) goto <D.22784>; else goto <D.22786>;
  <D.22786>:
  <D.23250>:
  mono_debug_free_method_jit_info (jit);
}


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

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


print_var_info (struct MonoDebugVarInfo * info, int idx, const char * name, const char * type)
{
  unsigned int D.23257;
  unsigned int D.23258;
  int D.23259;
  int D.23260;
  const char * D.23261;
  unsigned int D.23262;
  const char * D.23263;
  const char * D.23264;
  const char * D.23265;

  D.23257 = info->index;
  D.23258 = D.23257 & 4026531840;
  switch (D.23258) <default: <D.22771>, case 0: <D.22764>, case 268435456: <D.22766>, case 536870912: <D.22770>, case 1073741824: <D.22767>, case 1342177280: <D.22768>, case 1610612736: <D.22769>>
  <D.22764>:
  D.23257 = info->index;
  D.23259 = (int) D.23257;
  D.23260 = D.23259 & 268435455;
  D.23261 = mono_arch_regname (D.23260);
  monoeg_g_print ("%s %s (%d) in register %s\n", type, name, idx, D.23261);
  goto <D.22765>;
  <D.22766>:
  D.23262 = info->offset;
  D.23257 = info->index;
  D.23259 = (int) D.23257;
  D.23260 = D.23259 & 268435455;
  D.23263 = mono_arch_regname (D.23260);
  monoeg_g_print ("%s %s (%d) in memory: base register %s + %d\n", type, name, idx, D.23263, D.23262);
  goto <D.22765>;
  <D.22767>:
  D.23262 = info->offset;
  D.23257 = info->index;
  D.23259 = (int) D.23257;
  D.23260 = D.23259 & 268435455;
  D.23264 = mono_arch_regname (D.23260);
  monoeg_g_print ("%s %s (%d) in indir memory: base register %s + %d\n", type, name, idx, D.23264, D.23262);
  goto <D.22765>;
  <D.22768>:
  monoeg_g_print ("%s %s (%d) gsharedvt local.\n", type, name, idx);
  goto <D.22765>;
  <D.22769>:
  D.23262 = info->offset;
  D.23257 = info->index;
  D.23259 = (int) D.23257;
  D.23260 = D.23259 & 268435455;
  D.23265 = mono_arch_regname (D.23260);
  monoeg_g_print ("%s %s (%d) vt address: base register %s + %d\n", type, name, idx, D.23265, D.23262);
  goto <D.22765>;
  <D.22770>:
  <D.22771>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 636);
  <D.22765>:
}


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

  desc = mono_method_desc_new (method_name, include_namespace);
  if (desc == 0B) goto <D.23266>; else goto <D.23267>;
  <D.23266>:
  D.23268 = 0;
  return D.23268;
  <D.23267>:
  D.23268 = mono_debugger_insert_breakpoint_full (desc);
  return D.23268;
}


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 * breakpoints.20;
  int D.23277;
  unsigned int D.23278;
  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.23274>; else goto <D.23275>;
  <D.23274>:
  breakpoints.20 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.20;
  <D.23275>:
  breakpoints.19 = breakpoints;
  monoeg_g_ptr_array_add (breakpoints.19, info);
  D.23278 = info->index;
  D.23277 = (int) D.23278;
  return D.23277;
}


mono_debugger_method_has_breakpoint (struct MonoMethod * method)
{
  struct GPtrArray * breakpoints.21;
  int D.23283;
  void * * D.23284;
  long unsigned int D.23285;
  long unsigned int D.23286;
  void * * D.23287;
  struct MonoMethodDesc * D.23288;
  int D.23289;
  unsigned int D.23292;
  unsigned int i.22;
  unsigned int D.23294;
  int i;

  breakpoints.21 = breakpoints;
  if (breakpoints.21 == 0B) goto <D.23281>; else goto <D.23282>;
  <D.23281>:
  D.23283 = 0;
  return D.23283;
  <D.23282>:
  i = 0;
  goto <D.22805>;
  <D.22804>:
  {
    struct MiniDebugBreakpointInfo * info;

    breakpoints.21 = breakpoints;
    D.23284 = breakpoints.21->pdata;
    D.23285 = (long unsigned int) i;
    D.23286 = D.23285 * 8;
    D.23287 = D.23284 + D.23286;
    info = *D.23287;
    D.23288 = info->desc;
    D.23289 = mono_method_desc_full_match (D.23288, method);
    if (D.23289 == 0) goto <D.23290>; else goto <D.23291>;
    <D.23290>:
    // predicted unlikely by continue predictor.
    goto <D.22803>;
    <D.23291>:
    D.23292 = info->index;
    D.23283 = (int) D.23292;
    return D.23283;
  }
  <D.22803>:
  i = i + 1;
  <D.22805>:
  i.22 = (unsigned int) i;
  breakpoints.21 = breakpoints;
  D.23294 = breakpoints.21->len;
  if (i.22 < D.23294) goto <D.22804>; else goto <D.22806>;
  <D.22806>:
  D.23283 = 0;
  return D.23283;
}