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

  D.24884 = mono_debug_enabled ();
  if (D.24884 == 0) goto <D.24885>; else goto <D.24886>;
  <D.24885>:
  return;
  <D.24886>:
  info = monoeg_malloc0 (16);
  info->breakpoint_id = breakpoint_id;
  cfg->debug_info = info;
}


mono_debug_open_method (struct MonoCompile * cfg)
{
  struct MonoMethod * D.24890;
  struct MonoClass * D.24891;
  _Bool D.24892;
  long int D.24893;
  long int D.24894;
  struct GArray * D.24897;
  short unsigned int D.24898;
  unsigned int D.24899;
  unsigned int D.24900;
  unsigned int D.24901;
  void * D.24902;
  struct MiniDebugMethodInfo * info;
  struct MonoDebugMethodJitInfo * jit;
  struct MonoMethodHeader * header;

  info = cfg->debug_info;
  if (info == 0B) goto <D.24888>; else goto <D.24889>;
  <D.24888>:
  return;
  <D.24889>:
  D.24890 = cfg->method;
  D.24891 = D.24890->klass;
  mono_class_init (D.24891);
  header = cfg->header;
  D.24892 = header == 0B;
  D.24893 = (long int) D.24892;
  D.24894 = __builtin_expect (D.24893, 0);
  if (D.24894 != 0) goto <D.24895>; else goto <D.24896>;
  <D.24895>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 77, "header");
  <D.24896>:
  jit = monoeg_malloc0 (56);
  info->jit = jit;
  D.24897 = monoeg_g_array_new (0, 1, 8);
  info->line_numbers = D.24897;
  D.24898 = header->num_locals;
  D.24899 = (unsigned int) D.24898;
  jit->num_locals = D.24899;
  D.24900 = jit->num_locals;
  D.24901 = D.24900 * 24;
  D.24902 = monoeg_malloc0 (D.24901);
  jit->locals = D.24902;
}


mono_debug_close_method (struct MonoCompile * cfg)
{
  struct MonoDebugMethodJitInfo * D.24907;
  unsigned char * D.24910;
  unsigned int D.24911;
  unsigned int D.24912;
  unsigned int D.24913;
  unsigned int D.24916;
  short unsigned int D.24917;
  unsigned int D.24918;
  unsigned int D.24919;
  unsigned int D.24920;
  void * D.24921;
  struct MonoInst * * D.24922;
  unsigned int i.0;
  unsigned int D.24924;
  struct MonoInst * * D.24925;
  struct MonoInst * D.24926;
  struct MonoDebugVarInfo * D.24927;
  unsigned int D.24928;
  struct MonoDebugVarInfo * D.24929;
  unsigned int i.1;
  unsigned int D.24931;
  unsigned char D.24932;
  unsigned char D.24933;
  void * D.24936;
  struct MonoInst * * D.24937;
  struct MonoInst * D.24938;
  struct MonoDebugVarInfo * D.24939;
  <unnamed-unsigned:1> D.24940;
  int D.24941;
  int D.24942;
  unsigned int D.24943;
  unsigned int D.24944;
  struct MonoInst * * D.24945;
  struct MonoInst * D.24946;
  struct MonoDebugVarInfo * D.24947;
  struct MonoDebugVarInfo * D.24948;
  struct MonoInst * D.24949;
  void * D.24952;
  void * D.24953;
  struct MonoDebugVarInfo * D.24954;
  struct MonoInst * D.24955;
  struct MonoDebugVarInfo * D.24956;
  struct GArray * D.24957;
  int D.24958;
  unsigned int D.24959;
  unsigned int D.24960;
  unsigned int D.24961;
  void * D.24962;
  struct MonoDebugLineNumberEntry * D.24963;
  unsigned int D.24964;
  struct MonoDebugLineNumberEntry * D.24965;
  gchar * D.24966;
  struct MonoDebugLineNumberEntry * D.24967;
  struct MonoMethod * D.24968;
  struct MonoDomain * D.24969;
  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.24904>; else goto <D.24906>;
  <D.24906>:
  D.24907 = info->jit;
  if (D.24907 == 0B) goto <D.24904>; else goto <D.24905>;
  <D.24904>:
  if (info != 0B) goto <D.24908>; else goto <D.24909>;
  <D.24908>:
  monoeg_g_free (info);
  <D.24909>:
  return;
  <D.24905>:
  method = cfg->method;
  header = cfg->header;
  sig = mono_method_signature (method);
  jit = info->jit;
  D.24910 = cfg->native_code;
  jit->code_start = D.24910;
  D.24911 = cfg->epilog_begin;
  jit->epilogue_begin = D.24911;
  D.24912 = cfg->code_len;
  jit->code_size = D.24912;
  D.24913 = jit->epilogue_begin;
  if (D.24913 != 0) goto <D.24914>; else goto <D.24915>;
  <D.24914>:
  D.24913 = jit->epilogue_begin;
  D.24916 = header->code_size;
  record_line_number (info, D.24913, D.24916);
  <D.24915>:
  D.24917 = sig->param_count;
  D.24918 = (unsigned int) D.24917;
  jit->num_params = D.24918;
  D.24919 = jit->num_params;
  D.24920 = D.24919 * 24;
  D.24921 = monoeg_malloc0 (D.24920);
  jit->params = D.24921;
  i = 0;
  goto <D.24710>;
  <D.24709>:
  D.24922 = cfg->locals;
  i.0 = (unsigned int) i;
  D.24924 = i.0 * 4;
  D.24925 = D.24922 + D.24924;
  D.24926 = *D.24925;
  D.24927 = jit->locals;
  i.0 = (unsigned int) i;
  D.24928 = i.0 * 24;
  D.24929 = D.24927 + D.24928;
  write_variable (D.24926, D.24929);
  i = i + 1;
  <D.24710>:
  i.1 = (unsigned int) i;
  D.24931 = jit->num_locals;
  if (i.1 < D.24931) goto <D.24709>; else goto <D.24711>;
  <D.24711>:
  D.24932 = BIT_FIELD_REF <*sig, 8, 80>;
  D.24933 = D.24932 & 64;
  if (D.24933 != 0) goto <D.24934>; else goto <D.24935>;
  <D.24934>:
  D.24936 = monoeg_malloc0 (24);
  jit->this_var = D.24936;
  D.24937 = cfg->args;
  D.24938 = *D.24937;
  D.24939 = jit->this_var;
  write_variable (D.24938, D.24939);
  <D.24935>:
  i = 0;
  goto <D.24713>;
  <D.24712>:
  D.24937 = cfg->args;
  D.24940 = sig->hasthis;
  D.24941 = (int) D.24940;
  D.24942 = D.24941 + i;
  D.24943 = (unsigned int) D.24942;
  D.24944 = D.24943 * 4;
  D.24945 = D.24937 + D.24944;
  D.24946 = *D.24945;
  D.24947 = jit->params;
  i.0 = (unsigned int) i;
  D.24928 = i.0 * 24;
  D.24948 = D.24947 + D.24928;
  write_variable (D.24946, D.24948);
  i = i + 1;
  <D.24713>:
  i.1 = (unsigned int) i;
  D.24919 = jit->num_params;
  if (i.1 < D.24919) goto <D.24712>; else goto <D.24714>;
  <D.24714>:
  D.24949 = cfg->gsharedvt_info_var;
  if (D.24949 != 0B) goto <D.24950>; else goto <D.24951>;
  <D.24950>:
  D.24952 = monoeg_malloc0 (24);
  jit->gsharedvt_info_var = D.24952;
  D.24953 = monoeg_malloc0 (24);
  jit->gsharedvt_locals_var = D.24953;
  D.24949 = cfg->gsharedvt_info_var;
  D.24954 = jit->gsharedvt_info_var;
  write_variable (D.24949, D.24954);
  D.24955 = cfg->gsharedvt_locals_var;
  D.24956 = jit->gsharedvt_locals_var;
  write_variable (D.24955, D.24956);
  <D.24951>:
  D.24957 = info->line_numbers;
  D.24958 = D.24957->len;
  D.24959 = (unsigned int) D.24958;
  jit->num_line_numbers = D.24959;
  D.24960 = jit->num_line_numbers;
  D.24961 = D.24960 * 8;
  D.24962 = monoeg_malloc0 (D.24961);
  jit->line_numbers = D.24962;
  i = 0;
  goto <D.24716>;
  <D.24715>:
  D.24963 = jit->line_numbers;
  i.0 = (unsigned int) i;
  D.24964 = i.0 * 8;
  D.24965 = D.24963 + D.24964;
  D.24957 = info->line_numbers;
  D.24966 = D.24957->data;
  i.0 = (unsigned int) i;
  D.24964 = i.0 * 8;
  D.24967 = D.24966 + D.24964;
  *D.24965 = *D.24967;
  i = i + 1;
  <D.24716>:
  i.1 = (unsigned int) i;
  D.24960 = jit->num_line_numbers;
  if (i.1 < D.24960) goto <D.24715>; else goto <D.24717>;
  <D.24717>:
  D.24968 = cfg->method_to_register;
  D.24969 = cfg->domain;
  debug_info = mono_debug_add_method (D.24968, jit, D.24969);
  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.24971;
  struct MonoDebugLineNumberEntry lne;

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


write_variable (struct MonoInst * inst, struct MonoDebugVarInfo * var)
{
  struct MonoType * D.24972;
  short unsigned int D.24973;
  int D.24976;
  unsigned int D.24977;
  unsigned char D.24979;
  int D.24980;
  int D.24981;
  int D.24987;
  int D.24988;
  unsigned int D.24989;
  int D.24990;
  unsigned int D.24991;
  int D.24995;
  unsigned int D.24996;
  int D.25000;
  int D.25001;
  unsigned int D.25002;
  short unsigned int D.25006;
  _Bool D.25007;
  long int D.25008;
  long int D.25009;
  int D.25012;
  unsigned int D.25013;
  int D.25014;
  int D.25015;
  unsigned int D.25016;

  D.24972 = inst->data.op[1].vtype;
  var->type = D.24972;
  D.24973 = inst->opcode;
  if (D.24973 == 366) goto <D.24974>; else goto <D.24975>;
  <D.24974>:
  D.24976 = inst->dreg;
  D.24977 = (unsigned int) D.24976;
  var->index = D.24977;
  goto <D.24978>;
  <D.24975>:
  D.24979 = inst->flags;
  D.24980 = (int) D.24979;
  D.24981 = D.24980 & 2;
  if (D.24981 != 0) goto <D.24982>; else goto <D.24983>;
  <D.24982>:
  var->index = 805306368;
  goto <D.24984>;
  <D.24983>:
  D.24973 = inst->opcode;
  if (D.24973 == 367) goto <D.24985>; else goto <D.24986>;
  <D.24985>:
  D.24987 = inst->sreg1;
  D.24988 = D.24987 | 268435456;
  D.24989 = (unsigned int) D.24988;
  var->index = D.24989;
  D.24990 = inst->data.op[0].const_val;
  D.24991 = (unsigned int) D.24990;
  var->offset = D.24991;
  goto <D.24992>;
  <D.24986>:
  D.24973 = inst->opcode;
  if (D.24973 == 332) goto <D.24993>; else goto <D.24994>;
  <D.24993>:
  D.24987 = inst->sreg1;
  D.24995 = D.24987 | 1073741824;
  D.24996 = (unsigned int) D.24995;
  var->index = D.24996;
  D.24990 = inst->data.op[0].const_val;
  D.24991 = (unsigned int) D.24990;
  var->offset = D.24991;
  goto <D.24997>;
  <D.24994>:
  D.24973 = inst->opcode;
  if (D.24973 == 331) goto <D.24998>; else goto <D.24999>;
  <D.24998>:
  D.25000 = inst->data.op[1].const_val;
  D.25001 = D.25000 | 1342177280;
  D.25002 = (unsigned int) D.25001;
  var->index = D.25002;
  goto <D.25003>;
  <D.24999>:
  D.24973 = inst->opcode;
  if (D.24973 == 368) goto <D.25004>; else goto <D.25005>;
  <D.25004>:
  {
    struct MonoInst * vtaddr;

    vtaddr = inst->data.op[0].src;
    D.25006 = vtaddr->opcode;
    D.25007 = D.25006 != 367;
    D.25008 = (long int) D.25007;
    D.25009 = __builtin_expect (D.25008, 0);
    if (D.25009 != 0) goto <D.25010>; else goto <D.25011>;
    <D.25010>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 107, "vtaddr->opcode == OP_REGOFFSET");
    <D.25011>:
    D.25012 = vtaddr->data.op[0].const_val;
    D.25013 = (unsigned int) D.25012;
    var->offset = D.25013;
    D.25014 = vtaddr->sreg1;
    D.25015 = D.25014 | 1610612736;
    D.25016 = (unsigned int) D.25015;
    var->index = D.25016;
  }
  goto <D.25017>;
  <D.25005>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 111);
  <D.25017>:
  <D.25003>:
  <D.24997>:
  <D.24992>:
  <D.24984>:
  <D.24978>:
}


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

}


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

  info = cfg->debug_info;
  if (info != 0B) goto <D.25018>; else goto <D.25019>;
  <D.25018>:
  D.25020 = info->line_numbers;
  if (D.25020 != 0B) goto <D.25021>; else goto <D.25022>;
  <D.25021>:
  D.25020 = info->line_numbers;
  monoeg_g_array_free (D.25020, 1);
  <D.25022>:
  monoeg_g_free (info);
  cfg->debug_info = 0B;
  <D.25019>:
}


mono_debug_record_line_number (struct MonoCompile * cfg, struct MonoInst * ins, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.25026;
  const unsigned char * D.25028;
  _Bool D.25029;
  long int D.25030;
  long int D.25031;
  const unsigned char * D.25036;
  unsigned int D.25038;
  const unsigned char * D.25039;
  int D.25040;
  int D.25041;
  int D.25042;
  unsigned int D.25043;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.25023>; else goto <D.25025>;
  <D.25025>:
  D.25026 = info->jit;
  if (D.25026 == 0B) goto <D.25023>; else goto <D.25027>;
  <D.25027>:
  D.25028 = ins->cil_code;
  if (D.25028 == 0B) goto <D.25023>; else goto <D.25024>;
  <D.25023>:
  return;
  <D.25024>:
  header = cfg->header;
  D.25029 = header == 0B;
  D.25030 = (long int) D.25029;
  D.25031 = __builtin_expect (D.25030, 0);
  if (D.25031 != 0) goto <D.25032>; else goto <D.25033>;
  <D.25032>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 308, "header");
  <D.25033>:
  D.25028 = ins->cil_code;
  D.25036 = header->code;
  if (D.25028 < D.25036) goto <D.25034>; else goto <D.25037>;
  <D.25037>:
  D.25028 = ins->cil_code;
  D.25036 = header->code;
  D.25038 = header->code_size;
  D.25039 = D.25036 + D.25038;
  if (D.25028 > D.25039) goto <D.25034>; else goto <D.25035>;
  <D.25034>:
  return;
  <D.25035>:
  D.25028 = ins->cil_code;
  D.25040 = (int) D.25028;
  D.25036 = header->code;
  D.25041 = (int) D.25036;
  D.25042 = D.25040 - D.25041;
  offset = (guint32) D.25042;
  D.25043 = info->has_line_numbers;
  if (D.25043 == 0) goto <D.25044>; else goto <D.25045>;
  <D.25044>:
  D.25026 = info->jit;
  D.25026->prologue_end = address;
  info->has_line_numbers = 1;
  <D.25045>:
  record_line_number (info, address, offset);
}


mono_debug_open_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.25050;
  unsigned char * D.25052;
  _Bool D.25053;
  long int D.25054;
  long int D.25055;
  const unsigned char * D.25060;
  unsigned int D.25062;
  const unsigned char * D.25063;
  int D.25064;
  int D.25065;
  int D.25066;
  unsigned int D.25067;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.25047>; else goto <D.25049>;
  <D.25049>:
  D.25050 = info->jit;
  if (D.25050 == 0B) goto <D.25047>; else goto <D.25051>;
  <D.25051>:
  D.25052 = bb->cil_code;
  if (D.25052 == 0B) goto <D.25047>; else goto <D.25048>;
  <D.25047>:
  return;
  <D.25048>:
  header = cfg->header;
  D.25053 = header == 0B;
  D.25054 = (long int) D.25053;
  D.25055 = __builtin_expect (D.25054, 0);
  if (D.25055 != 0) goto <D.25056>; else goto <D.25057>;
  <D.25056>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 335, "header");
  <D.25057>:
  D.25052 = bb->cil_code;
  D.25060 = header->code;
  if (D.25052 < D.25060) goto <D.25058>; else goto <D.25061>;
  <D.25061>:
  D.25052 = bb->cil_code;
  D.25060 = header->code;
  D.25062 = header->code_size;
  D.25063 = D.25060 + D.25062;
  if (D.25052 > D.25063) goto <D.25058>; else goto <D.25059>;
  <D.25058>:
  return;
  <D.25059>:
  D.25052 = bb->cil_code;
  D.25064 = (int) D.25052;
  D.25060 = header->code;
  D.25065 = (int) D.25060;
  D.25066 = D.25064 - D.25065;
  offset = (guint32) D.25066;
  D.25067 = info->has_line_numbers;
  if (D.25067 == 0) goto <D.25068>; else goto <D.25069>;
  <D.25068>:
  D.25050 = info->jit;
  D.25050->prologue_end = address;
  info->has_line_numbers = 1;
  <D.25069>:
  record_line_number (info, address, offset);
}


mono_debug_serialize_debug_info (struct MonoCompile * cfg, guint8 * * out_buf, guint32 * buf_len)
{
  struct MonoMethod * D.25071;
  struct MonoDomain * D.25072;
  unsigned int D.25075;
  unsigned int D.25076;
  unsigned int D.25077;
  unsigned int D.25078;
  unsigned int D.25079;
  unsigned int D.25080;
  unsigned int D.25081;
  unsigned int D.25082;
  int D.25083;
  guint8 * p.2;
  unsigned int D.25085;
  int D.25086;
  unsigned int D.25087;
  int D.25088;
  struct MonoDebugVarInfo * D.25089;
  unsigned int i.3;
  unsigned int D.25091;
  struct MonoDebugVarInfo * D.25092;
  unsigned int i.4;
  struct MonoMethodSignature * D.25094;
  unsigned char D.25095;
  unsigned char D.25096;
  struct MonoDebugVarInfo * D.25099;
  struct MonoDebugVarInfo * D.25100;
  struct MonoDebugVarInfo * D.25101;
  struct MonoDebugVarInfo * D.25102;
  struct MonoDebugVarInfo * D.25105;
  int D.25107;
  struct MonoDebugLineNumberEntry * D.25108;
  unsigned int D.25109;
  unsigned int D.25110;
  unsigned int D.25111;
  int D.25112;
  unsigned int D.25113;
  unsigned int D.25114;
  int D.25115;
  int p.5;
  int buf.6;
  int D.25118;
  unsigned int D.25119;
  _Bool D.25120;
  long int D.25121;
  long int D.25122;
  struct MonoDebugMethodJitInfo * jit;
  guint32 size;
  guint32 prev_offset;
  guint32 prev_native_offset;
  guint8 * buf;
  guint8 * p;
  int i;

  try
    {
      D.25071 = cfg->method;
      D.25072 = mono_domain_get ();
      jit = mono_debug_find_method (D.25071, D.25072);
      if (jit == 0B) goto <D.25073>; else goto <D.25074>;
      <D.25073>:
      *buf_len = 0;
      return;
      <D.25074>:
      D.25075 = jit->num_params;
      D.25076 = jit->num_locals;
      D.25077 = D.25075 + D.25076;
      D.25078 = jit->num_line_numbers;
      D.25079 = D.25077 + D.25078;
      D.25080 = D.25079 + 1;
      D.25081 = D.25080 * 10;
      size = D.25081 + 64;
      buf = monoeg_malloc (size);
      p = buf;
      D.25082 = jit->epilogue_begin;
      D.25083 = (int) D.25082;
      p.2 = p;
      encode_value (D.25083, p.2, &p);
      D.25085 = jit->prologue_end;
      D.25086 = (int) D.25085;
      p.2 = p;
      encode_value (D.25086, p.2, &p);
      D.25087 = jit->code_size;
      D.25088 = (int) D.25087;
      p.2 = p;
      encode_value (D.25088, p.2, &p);
      i = 0;
      goto <D.24777>;
      <D.24776>:
      D.25089 = jit->params;
      i.3 = (unsigned int) i;
      D.25091 = i.3 * 24;
      D.25092 = D.25089 + D.25091;
      p.2 = p;
      serialize_variable (D.25092, p.2, &p);
      i = i + 1;
      <D.24777>:
      i.4 = (unsigned int) i;
      D.25075 = jit->num_params;
      if (i.4 < D.25075) goto <D.24776>; else goto <D.24778>;
      <D.24778>:
      D.25071 = cfg->method;
      D.25094 = mono_method_signature (D.25071);
      D.25095 = BIT_FIELD_REF <*D.25094, 8, 80>;
      D.25096 = D.25095 & 64;
      if (D.25096 != 0) goto <D.25097>; else goto <D.25098>;
      <D.25097>:
      D.25099 = jit->this_var;
      p.2 = p;
      serialize_variable (D.25099, p.2, &p);
      <D.25098>:
      i = 0;
      goto <D.24780>;
      <D.24779>:
      D.25100 = jit->locals;
      i.3 = (unsigned int) i;
      D.25091 = i.3 * 24;
      D.25101 = D.25100 + D.25091;
      p.2 = p;
      serialize_variable (D.25101, p.2, &p);
      i = i + 1;
      <D.24780>:
      i.4 = (unsigned int) i;
      D.25076 = jit->num_locals;
      if (i.4 < D.25076) goto <D.24779>; else goto <D.24781>;
      <D.24781>:
      D.25102 = jit->gsharedvt_info_var;
      if (D.25102 != 0B) goto <D.25103>; else goto <D.25104>;
      <D.25103>:
      p.2 = p;
      encode_value (1, p.2, &p);
      D.25102 = jit->gsharedvt_info_var;
      p.2 = p;
      serialize_variable (D.25102, p.2, &p);
      D.25105 = jit->gsharedvt_locals_var;
      p.2 = p;
      serialize_variable (D.25105, p.2, &p);
      goto <D.25106>;
      <D.25104>:
      p.2 = p;
      encode_value (0, p.2, &p);
      <D.25106>:
      D.25078 = jit->num_line_numbers;
      D.25107 = (int) D.25078;
      p.2 = p;
      encode_value (D.25107, p.2, &p);
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.24784>;
      <D.24783>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.25108 = jit->line_numbers;
        i.3 = (unsigned int) i;
        D.25109 = i.3 * 8;
        lne = D.25108 + D.25109;
        D.25110 = lne->il_offset;
        D.25111 = D.25110 - prev_offset;
        D.25112 = (int) D.25111;
        p.2 = p;
        encode_value (D.25112, p.2, &p);
        D.25113 = lne->native_offset;
        D.25114 = D.25113 - prev_native_offset;
        D.25115 = (int) D.25114;
        p.2 = p;
        encode_value (D.25115, p.2, &p);
        prev_offset = lne->il_offset;
        prev_native_offset = lne->native_offset;
      }
      i = i + 1;
      <D.24784>:
      i.4 = (unsigned int) i;
      D.25078 = jit->num_line_numbers;
      if (i.4 < D.25078) goto <D.24783>; else goto <D.24785>;
      <D.24785>:
      p.2 = p;
      p.5 = (int) p.2;
      buf.6 = (int) buf;
      D.25118 = p.5 - buf.6;
      D.25119 = (unsigned int) D.25118;
      D.25120 = D.25119 >= size;
      D.25121 = (long int) D.25120;
      D.25122 = __builtin_expect (D.25121, 0);
      if (D.25122 != 0) goto <D.25123>; else goto <D.25124>;
      <D.25123>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 491, "p - buf < size");
      <D.25124>:
      *out_buf = buf;
      p.2 = p;
      p.5 = (int) p.2;
      buf.6 = (int) buf;
      D.25118 = p.5 - buf.6;
      D.25119 = (unsigned int) D.25118;
      *buf_len = D.25119;
    }
  finally
    {
      p = {CLOBBER};
    }
}


serialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  unsigned int D.25128;
  int D.25129;
  guint8 * p.7;
  unsigned int D.25131;
  int D.25132;
  guint32 flags;

  D.25128 = var->index;
  flags = D.25128 & 4026531840;
  D.25128 = var->index;
  D.25129 = (int) D.25128;
  p.7 = p;
  encode_value (D.25129, p.7, &p);
  switch (flags) <default: <D.24763>, case 0: <D.24756>, case 268435456: <D.24758>, case 805306368: <D.24762>, case 1073741824: <D.24759>, case 1342177280: <D.24760>, case 1610612736: <D.24761>>
  <D.24756>:
  goto <D.24757>;
  <D.24758>:
  <D.24759>:
  D.25131 = var->offset;
  D.25132 = (int) D.25131;
  p.7 = p;
  encode_value (D.25132, p.7, &p);
  goto <D.24757>;
  <D.24760>:
  <D.24761>:
  <D.24762>:
  goto <D.24757>;
  <D.24763>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 435);
  <D.24757>:
  p.7 = p;
  *endbuf = p.7;
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.8;
  guint8 * p.9;
  unsigned char D.25138;
  int D.25142;
  signed char D.25143;
  signed char D.25144;
  unsigned char D.25145;
  guint8 * D.25146;
  unsigned char D.25147;
  int D.25151;
  signed char D.25152;
  signed char D.25153;
  unsigned char D.25154;
  int D.25155;
  unsigned char D.25156;
  guint8 * D.25157;
  unsigned char D.25158;
  guint8 * D.25159;
  unsigned int D.25161;
  unsigned char D.25162;
  guint8 * D.25163;
  guint8 * p;

  p = buf;
  value.8 = (unsigned int) value;
  if (value.8 <= 127) goto <D.25135>; else goto <D.25136>;
  <D.25135>:
  p.9 = p;
  p = p.9 + 1;
  D.25138 = (unsigned char) value;
  *p.9 = D.25138;
  goto <D.25139>;
  <D.25136>:
  value.8 = (unsigned int) value;
  if (value.8 <= 16383) goto <D.25140>; else goto <D.25141>;
  <D.25140>:
  D.25142 = value >> 8;
  D.25143 = (signed char) D.25142;
  D.25144 = D.25143 | -128;
  D.25145 = (unsigned char) D.25144;
  *p = D.25145;
  D.25146 = p + 1;
  D.25147 = (unsigned char) value;
  *D.25146 = D.25147;
  p = p + 2;
  goto <D.25148>;
  <D.25141>:
  value.8 = (unsigned int) value;
  if (value.8 <= 536870911) goto <D.25149>; else goto <D.25150>;
  <D.25149>:
  D.25151 = value >> 24;
  D.25152 = (signed char) D.25151;
  D.25153 = D.25152 | -64;
  D.25154 = (unsigned char) D.25153;
  *p = D.25154;
  D.25146 = p + 1;
  D.25155 = value >> 16;
  D.25156 = (unsigned char) D.25155;
  *D.25146 = D.25156;
  D.25157 = p + 2;
  D.25142 = value >> 8;
  D.25158 = (unsigned char) D.25142;
  *D.25157 = D.25158;
  D.25159 = p + 3;
  D.25147 = (unsigned char) value;
  *D.25159 = D.25147;
  p = p + 4;
  goto <D.25160>;
  <D.25150>:
  *p = 255;
  D.25146 = p + 1;
  value.8 = (unsigned int) value;
  D.25161 = value.8 >> 24;
  D.25162 = (unsigned char) D.25161;
  *D.25146 = D.25162;
  D.25157 = p + 2;
  D.25155 = value >> 16;
  D.25156 = (unsigned char) D.25155;
  *D.25157 = D.25156;
  D.25159 = p + 3;
  D.25142 = value >> 8;
  D.25158 = (unsigned char) D.25142;
  *D.25159 = D.25158;
  D.25163 = p + 4;
  D.25147 = (unsigned char) value;
  *D.25163 = D.25147;
  p = p + 5;
  <D.25160>:
  <D.25148>:
  <D.25139>:
  if (endbuf != 0B) goto <D.25164>; else goto <D.25165>;
  <D.25164>:
  *endbuf = p;
  <D.25165>:
}


mono_debug_add_aot_method (struct MonoDomain * domain, struct MonoMethod * method, guint8 * code_start, guint8 * debug_info, guint32 debug_info_len)
{
  int D.25166;
  short unsigned int D.25171;
  unsigned int D.25172;
  unsigned int D.25173;
  short unsigned int D.25175;
  unsigned int D.25176;
  unsigned int D.25177;
  unsigned char D.25179;
  unsigned char D.25180;
  struct MonoDebugMethodJitInfo * jit;

  D.25166 = mono_debug_enabled ();
  if (D.25166 == 0) goto <D.25167>; else goto <D.25168>;
  <D.25167>:
  return;
  <D.25168>:
  D.25171 = method->iflags;
  D.25172 = (unsigned int) D.25171;
  D.25173 = D.25172 & 4099;
  if (D.25173 != 0) goto <D.25169>; else goto <D.25174>;
  <D.25174>:
  D.25175 = method->flags;
  D.25176 = (unsigned int) D.25175;
  D.25177 = D.25176 & 9216;
  if (D.25177 != 0) goto <D.25169>; else goto <D.25178>;
  <D.25178>:
  D.25179 = BIT_FIELD_REF <*method, 8, 160>;
  D.25180 = D.25179 & 124;
  if (D.25180 != 0) goto <D.25169>; else goto <D.25170>;
  <D.25169>:
  return;
  <D.25170>:
  if (debug_info_len == 0) goto <D.25181>; else goto <D.25182>;
  <D.25181>:
  return;
  <D.25182>:
  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.25184;
  long int D.25185;
  long int D.25186;
  short unsigned int D.25189;
  unsigned int D.25190;
  unsigned int D.25191;
  unsigned int D.25192;
  void * D.25193;
  struct MonoMethodSignature * D.25194;
  short unsigned int D.25195;
  unsigned int D.25196;
  unsigned int D.25197;
  unsigned int D.25198;
  void * D.25199;
  guint8 * p.10;
  int D.25201;
  unsigned int D.25202;
  int D.25203;
  unsigned int D.25204;
  int D.25205;
  unsigned int D.25206;
  struct MonoDebugVarInfo * D.25207;
  unsigned int i.11;
  unsigned int D.25209;
  struct MonoDebugVarInfo * D.25210;
  unsigned int i.12;
  struct MonoMethodSignature * D.25212;
  unsigned char D.25213;
  unsigned char D.25214;
  void * D.25217;
  struct MonoDebugVarInfo * D.25218;
  struct MonoDebugVarInfo * D.25219;
  struct MonoDebugVarInfo * D.25220;
  int D.25221;
  void * D.25224;
  void * D.25225;
  struct MonoDebugVarInfo * D.25226;
  struct MonoDebugVarInfo * D.25227;
  int D.25228;
  unsigned int D.25229;
  unsigned int D.25230;
  unsigned int D.25231;
  void * D.25232;
  struct MonoDebugLineNumberEntry * D.25233;
  unsigned int D.25234;
  int D.25235;
  int D.25236;
  unsigned int native_offset.13;
  unsigned int offset.14;
  struct MonoDebugMethodJitInfo * D.25239;
  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.25184 = header == 0B;
      D.25185 = (long int) D.25184;
      D.25186 = __builtin_expect (D.25185, 0);
      if (D.25186 != 0) goto <D.25187>; else goto <D.25188>;
      <D.25187>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 533, "header");
      <D.25188>:
      jit = monoeg_malloc0 (56);
      jit->code_start = code_start;
      D.25189 = header->num_locals;
      D.25190 = (unsigned int) D.25189;
      jit->num_locals = D.25190;
      D.25191 = jit->num_locals;
      D.25192 = D.25191 * 24;
      D.25193 = monoeg_malloc0 (D.25192);
      jit->locals = D.25193;
      D.25194 = mono_method_signature (method);
      D.25195 = D.25194->param_count;
      D.25196 = (unsigned int) D.25195;
      jit->num_params = D.25196;
      D.25197 = jit->num_params;
      D.25198 = D.25197 * 24;
      D.25199 = monoeg_malloc0 (D.25198);
      jit->params = D.25199;
      p = buf;
      p.10 = p;
      D.25201 = decode_value (p.10, &p);
      D.25202 = (unsigned int) D.25201;
      jit->epilogue_begin = D.25202;
      p.10 = p;
      D.25203 = decode_value (p.10, &p);
      D.25204 = (unsigned int) D.25203;
      jit->prologue_end = D.25204;
      p.10 = p;
      D.25205 = decode_value (p.10, &p);
      D.25206 = (unsigned int) D.25205;
      jit->code_size = D.25206;
      i = 0;
      goto <D.24815>;
      <D.24814>:
      D.25207 = jit->params;
      i.11 = (unsigned int) i;
      D.25209 = i.11 * 24;
      D.25210 = D.25207 + D.25209;
      p.10 = p;
      deserialize_variable (D.25210, p.10, &p);
      i = i + 1;
      <D.24815>:
      i.12 = (unsigned int) i;
      D.25197 = jit->num_params;
      if (i.12 < D.25197) goto <D.24814>; else goto <D.24816>;
      <D.24816>:
      D.25212 = mono_method_signature (method);
      D.25213 = BIT_FIELD_REF <*D.25212, 8, 80>;
      D.25214 = D.25213 & 64;
      if (D.25214 != 0) goto <D.25215>; else goto <D.25216>;
      <D.25215>:
      D.25217 = monoeg_malloc0 (24);
      jit->this_var = D.25217;
      D.25218 = jit->this_var;
      p.10 = p;
      deserialize_variable (D.25218, p.10, &p);
      <D.25216>:
      i = 0;
      goto <D.24818>;
      <D.24817>:
      D.25219 = jit->locals;
      i.11 = (unsigned int) i;
      D.25209 = i.11 * 24;
      D.25220 = D.25219 + D.25209;
      p.10 = p;
      deserialize_variable (D.25220, p.10, &p);
      i = i + 1;
      <D.24818>:
      i.12 = (unsigned int) i;
      D.25191 = jit->num_locals;
      if (i.12 < D.25191) goto <D.24817>; else goto <D.24819>;
      <D.24819>:
      p.10 = p;
      D.25221 = decode_value (p.10, &p);
      if (D.25221 != 0) goto <D.25222>; else goto <D.25223>;
      <D.25222>:
      D.25224 = monoeg_malloc0 (24);
      jit->gsharedvt_info_var = D.25224;
      D.25225 = monoeg_malloc0 (24);
      jit->gsharedvt_locals_var = D.25225;
      D.25226 = jit->gsharedvt_info_var;
      p.10 = p;
      deserialize_variable (D.25226, p.10, &p);
      D.25227 = jit->gsharedvt_locals_var;
      p.10 = p;
      deserialize_variable (D.25227, p.10, &p);
      <D.25223>:
      p.10 = p;
      D.25228 = decode_value (p.10, &p);
      D.25229 = (unsigned int) D.25228;
      jit->num_line_numbers = D.25229;
      D.25230 = jit->num_line_numbers;
      D.25231 = D.25230 * 8;
      D.25232 = monoeg_malloc0 (D.25231);
      jit->line_numbers = D.25232;
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.24822>;
      <D.24821>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.25233 = jit->line_numbers;
        i.11 = (unsigned int) i;
        D.25234 = i.11 * 8;
        lne = D.25233 + D.25234;
        p.10 = p;
        D.25235 = decode_value (p.10, &p);
        offset = D.25235 + prev_offset;
        p.10 = p;
        D.25236 = decode_value (p.10, &p);
        native_offset = D.25236 + 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.24822>:
      i.12 = (unsigned int) i;
      D.25230 = jit->num_line_numbers;
      if (i.12 < D.25230) goto <D.24821>; else goto <D.24823>;
      <D.24823>:
      mono_metadata_free_mh (header);
      D.25239 = jit;
      return D.25239;
    }
  finally
    {
      p = {CLOBBER};
    }
}


deserialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  guint8 * p.15;
  int D.25243;
  unsigned int D.25244;
  unsigned int D.25245;
  int D.25246;
  unsigned int D.25247;
  guint32 flags;

  p.15 = p;
  D.25243 = decode_value (p.15, &p);
  D.25244 = (unsigned int) D.25243;
  var->index = D.25244;
  D.25245 = var->index;
  flags = D.25245 & 4026531840;
  switch (flags) <default: <D.24799>, case 0: <D.24792>, case 268435456: <D.24794>, case 805306368: <D.24798>, case 1073741824: <D.24795>, case 1342177280: <D.24796>, case 1610612736: <D.24797>>
  <D.24792>:
  goto <D.24793>;
  <D.24794>:
  <D.24795>:
  p.15 = p;
  D.25246 = decode_value (p.15, &p);
  D.25247 = (unsigned int) D.25246;
  var->offset = D.25247;
  goto <D.24793>;
  <D.24796>:
  <D.24797>:
  <D.24798>:
  goto <D.24793>;
  <D.24799>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 518);
  <D.24793>:
  p.15 = p;
  *endbuf = p.15;
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.16;
  int D.25253;
  int D.25254;
  int D.25257;
  int D.25258;
  guint8 * D.25259;
  unsigned char D.25260;
  int D.25261;
  int D.25265;
  int D.25266;
  int D.25267;
  int D.25268;
  guint8 * D.25269;
  unsigned char D.25270;
  int D.25271;
  int D.25272;
  int D.25273;
  guint8 * D.25274;
  unsigned char D.25275;
  int D.25276;
  int D.25278;
  int D.25279;
  int D.25280;
  int D.25281;
  int D.25282;
  guint8 * D.25283;
  unsigned char D.25284;
  int D.25285;
  gint32 D.25288;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.16 = (signed char) b;
  if (b.16 >= 0) goto <D.25250>; else goto <D.25251>;
  <D.25250>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.25252>;
  <D.25251>:
  D.25253 = (int) b;
  D.25254 = D.25253 & 64;
  if (D.25254 == 0) goto <D.25255>; else goto <D.25256>;
  <D.25255>:
  D.25253 = (int) b;
  D.25257 = D.25253 & 63;
  D.25258 = D.25257 << 8;
  D.25259 = ptr + 1;
  D.25260 = *D.25259;
  D.25261 = (int) D.25260;
  len = D.25258 | D.25261;
  ptr = ptr + 2;
  goto <D.25262>;
  <D.25256>:
  if (b != 255) goto <D.25263>; else goto <D.25264>;
  <D.25263>:
  D.25253 = (int) b;
  D.25265 = D.25253 & 31;
  D.25266 = D.25265 << 24;
  D.25259 = ptr + 1;
  D.25260 = *D.25259;
  D.25261 = (int) D.25260;
  D.25267 = D.25261 << 16;
  D.25268 = D.25266 | D.25267;
  D.25269 = ptr + 2;
  D.25270 = *D.25269;
  D.25271 = (int) D.25270;
  D.25272 = D.25271 << 8;
  D.25273 = D.25268 | D.25272;
  D.25274 = ptr + 3;
  D.25275 = *D.25274;
  D.25276 = (int) D.25275;
  len = D.25273 | D.25276;
  ptr = ptr + 4;
  goto <D.25277>;
  <D.25264>:
  D.25259 = ptr + 1;
  D.25260 = *D.25259;
  D.25261 = (int) D.25260;
  D.25278 = D.25261 << 24;
  D.25269 = ptr + 2;
  D.25270 = *D.25269;
  D.25271 = (int) D.25270;
  D.25279 = D.25271 << 16;
  D.25280 = D.25278 | D.25279;
  D.25274 = ptr + 3;
  D.25275 = *D.25274;
  D.25276 = (int) D.25275;
  D.25281 = D.25276 << 8;
  D.25282 = D.25280 | D.25281;
  D.25283 = ptr + 4;
  D.25284 = *D.25283;
  D.25285 = (int) D.25284;
  len = D.25282 | D.25285;
  ptr = ptr + 5;
  <D.25277>:
  <D.25262>:
  <D.25252>:
  if (rptr != 0B) goto <D.25286>; else goto <D.25287>;
  <D.25286>:
  *rptr = ptr;
  <D.25287>:
  D.25288 = len;
  return D.25288;
}


mono_debug_print_vars (void * ip, gboolean only_arguments)
{
  struct MonoMethod * D.25292;
  unsigned int D.25297;
  unsigned int D.25298;
  struct MonoMethod * D.25299;
  struct MonoDebugVarInfo * D.25300;
  struct MonoDebugVarInfo * D.25303;
  unsigned int i.17;
  unsigned int D.25305;
  struct MonoDebugVarInfo * D.25306;
  const char * iftmp.18;
  unsigned int D.25308;
  char * * D.25309;
  char * D.25310;
  unsigned int i.19;
  struct MonoDebugVarInfo * D.25316;
  struct MonoDebugVarInfo * D.25317;
  unsigned int D.25318;
  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.25290>; else goto <D.25291>;
  <D.25290>:
  return;
  <D.25291>:
  D.25292 = jinfo_get_method (ji);
  jit = mono_debug_find_method (D.25292, domain);
  if (jit == 0B) goto <D.25293>; else goto <D.25294>;
  <D.25293>:
  return;
  <D.25294>:
  if (only_arguments != 0) goto <D.25295>; else goto <D.25296>;
  <D.25295>:
  {
    char * * names;

    D.25297 = jit->num_params;
    D.25298 = D.25297 * 4;
    names = monoeg_malloc (D.25298);
    D.25299 = jinfo_get_method (ji);
    mono_method_get_param_names (D.25299, names);
    D.25300 = jit->this_var;
    if (D.25300 != 0B) goto <D.25301>; else goto <D.25302>;
    <D.25301>:
    D.25300 = jit->this_var;
    print_var_info (D.25300, 0, "this", "Arg");
    <D.25302>:
    i = 0;
    goto <D.24856>;
    <D.24855>:
    D.25303 = jit->params;
    i.17 = (unsigned int) i;
    D.25305 = i.17 * 24;
    D.25306 = D.25303 + D.25305;
    i.17 = (unsigned int) i;
    D.25308 = i.17 * 4;
    D.25309 = names + D.25308;
    D.25310 = *D.25309;
    if (D.25310 != 0B) goto <D.25311>; else goto <D.25312>;
    <D.25311>:
    i.17 = (unsigned int) i;
    D.25308 = i.17 * 4;
    D.25309 = names + D.25308;
    iftmp.18 = *D.25309;
    goto <D.25313>;
    <D.25312>:
    iftmp.18 = "unknown name";
    <D.25313>:
    print_var_info (D.25306, i, iftmp.18, "Arg");
    i = i + 1;
    <D.24856>:
    i.19 = (unsigned int) i;
    D.25297 = jit->num_params;
    if (i.19 < D.25297) goto <D.24855>; else goto <D.24857>;
    <D.24857>:
    monoeg_g_free (names);
  }
  goto <D.25315>;
  <D.25296>:
  i = 0;
  goto <D.24859>;
  <D.24858>:
  D.25316 = jit->locals;
  i.17 = (unsigned int) i;
  D.25305 = i.17 * 24;
  D.25317 = D.25316 + D.25305;
  print_var_info (D.25317, i, "", "Local");
  i = i + 1;
  <D.24859>:
  i.19 = (unsigned int) i;
  D.25318 = jit->num_locals;
  if (i.19 < D.25318) goto <D.24858>; else goto <D.24860>;
  <D.24860>:
  <D.25315>:
  mono_debug_free_method_jit_info (jit);
}


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

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


print_var_info (struct MonoDebugVarInfo * info, int idx, const char * name, const char * type)
{
  unsigned int D.25322;
  unsigned int D.25323;
  int D.25324;
  int D.25325;
  const char * D.25326;
  const char * D.25327;
  unsigned int D.25328;
  const char * D.25329;
  const char * D.25330;

  D.25322 = info->index;
  D.25323 = D.25322 & 4026531840;
  switch (D.25323) <default: <D.24845>, case 0: <D.24838>, case 268435456: <D.24840>, case 536870912: <D.24844>, case 1073741824: <D.24841>, case 1342177280: <D.24842>, case 1610612736: <D.24843>>
  <D.24838>:
  D.25322 = info->index;
  D.25324 = (int) D.25322;
  D.25325 = D.25324 & 268435455;
  D.25326 = mono_arch_regname (D.25325);
  monoeg_g_print ("%s %s (%d) in register %s\n", type, name, idx, D.25326);
  goto <D.24839>;
  <D.24840>:
  D.25322 = info->index;
  D.25324 = (int) D.25322;
  D.25325 = D.25324 & 268435455;
  D.25327 = mono_arch_regname (D.25325);
  D.25328 = info->offset;
  monoeg_g_print ("%s %s (%d) in memory: base register %s + %d\n", type, name, idx, D.25327, D.25328);
  goto <D.24839>;
  <D.24841>:
  D.25322 = info->index;
  D.25324 = (int) D.25322;
  D.25325 = D.25324 & 268435455;
  D.25329 = mono_arch_regname (D.25325);
  D.25328 = info->offset;
  monoeg_g_print ("%s %s (%d) in indir memory: base register %s + %d\n", type, name, idx, D.25329, D.25328);
  goto <D.24839>;
  <D.24842>:
  monoeg_g_print ("%s %s (%d) gsharedvt local.\n", type, name, idx);
  goto <D.24839>;
  <D.24843>:
  D.25322 = info->index;
  D.25324 = (int) D.25322;
  D.25325 = D.25324 & 268435455;
  D.25330 = mono_arch_regname (D.25325);
  D.25328 = info->offset;
  monoeg_g_print ("%s %s (%d) vt address: base register %s + %d\n", type, name, idx, D.25330, D.25328);
  goto <D.24839>;
  <D.24844>:
  <D.24845>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 636);
  <D.24839>:
}


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

  desc = mono_method_desc_new (method_name, include_namespace);
  if (desc == 0B) goto <D.25331>; else goto <D.25332>;
  <D.25331>:
  D.25333 = 0;
  return D.25333;
  <D.25332>:
  D.25333 = mono_debugger_insert_breakpoint_full (desc);
  return D.25333;
}


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.25342;
  unsigned int D.25343;
  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.25339>; else goto <D.25340>;
  <D.25339>:
  breakpoints.24 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.24;
  <D.25340>:
  breakpoints.23 = breakpoints;
  monoeg_g_ptr_array_add (breakpoints.23, info);
  D.25343 = info->index;
  D.25342 = (int) D.25343;
  return D.25342;
}


mono_debugger_method_has_breakpoint (struct MonoMethod * method)
{
  struct GPtrArray * breakpoints.25;
  int D.25348;
  void * * D.25349;
  unsigned int i.26;
  unsigned int D.25351;
  void * * D.25352;
  struct MonoMethodDesc * D.25353;
  int D.25354;
  unsigned int D.25357;
  unsigned int i.27;
  unsigned int D.25359;
  int i;

  breakpoints.25 = breakpoints;
  if (breakpoints.25 == 0B) goto <D.25346>; else goto <D.25347>;
  <D.25346>:
  D.25348 = 0;
  return D.25348;
  <D.25347>:
  i = 0;
  goto <D.24879>;
  <D.24878>:
  {
    struct MiniDebugBreakpointInfo * info;

    breakpoints.25 = breakpoints;
    D.25349 = breakpoints.25->pdata;
    i.26 = (unsigned int) i;
    D.25351 = i.26 * 4;
    D.25352 = D.25349 + D.25351;
    info = *D.25352;
    D.25353 = info->desc;
    D.25354 = mono_method_desc_full_match (D.25353, method);
    if (D.25354 == 0) goto <D.25355>; else goto <D.25356>;
    <D.25355>:
    // predicted unlikely by continue predictor.
    goto <D.24877>;
    <D.25356>:
    D.25357 = info->index;
    D.25348 = (int) D.25357;
    return D.25348;
  }
  <D.24877>:
  i = i + 1;
  <D.24879>:
  i.27 = (unsigned int) i;
  breakpoints.25 = breakpoints;
  D.25359 = breakpoints.25->len;
  if (i.27 < D.25359) goto <D.24878>; else goto <D.24880>;
  <D.24880>:
  D.25348 = 0;
  return D.25348;
}