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

  D.22901 = mono_debug_enabled ();
  if (D.22901 == 0) goto <D.22902>; else goto <D.22903>;
  <D.22902>:
  return;
  <D.22903>:
  info = monoeg_malloc0 (24);
  info->breakpoint_id = breakpoint_id;
  cfg->debug_info = info;
}


mono_debug_open_method (struct MonoCompile * cfg)
{
  struct MonoMethod * D.22907;
  struct MonoClass * D.22908;
  _Bool D.22909;
  long int D.22910;
  long int D.22911;
  struct GArray * D.22914;
  short unsigned int D.22915;
  unsigned int D.22916;
  unsigned int D.22917;
  long unsigned int D.22918;
  long unsigned int D.22919;
  void * D.22920;
  struct MiniDebugMethodInfo * info;
  struct MonoDebugMethodJitInfo * jit;
  struct MonoMethodHeader * header;

  info = cfg->debug_info;
  if (info == 0B) goto <D.22905>; else goto <D.22906>;
  <D.22905>:
  return;
  <D.22906>:
  D.22907 = cfg->method;
  D.22908 = D.22907->klass;
  mono_class_init (D.22908);
  header = cfg->header;
  D.22909 = header == 0B;
  D.22910 = (long int) D.22909;
  D.22911 = __builtin_expect (D.22910, 0);
  if (D.22911 != 0) goto <D.22912>; else goto <D.22913>;
  <D.22912>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 77, "header");
  <D.22913>:
  jit = monoeg_malloc0 (104);
  info->jit = jit;
  D.22914 = monoeg_g_array_new (0, 1, 8);
  info->line_numbers = D.22914;
  D.22915 = header->num_locals;
  D.22916 = (unsigned int) D.22915;
  jit->num_locals = D.22916;
  D.22917 = jit->num_locals;
  D.22918 = (long unsigned int) D.22917;
  D.22919 = D.22918 * 32;
  D.22920 = monoeg_malloc0 (D.22919);
  jit->locals = D.22920;
}


mono_debug_close_method (struct MonoCompile * cfg)
{
  struct MonoDebugMethodJitInfo * D.22925;
  unsigned char * D.22928;
  unsigned int D.22929;
  unsigned int D.22930;
  unsigned int D.22931;
  unsigned int D.22934;
  short unsigned int D.22935;
  unsigned int D.22936;
  unsigned int D.22937;
  long unsigned int D.22938;
  long unsigned int D.22939;
  void * D.22940;
  struct MonoInst * * D.22941;
  long unsigned int D.22942;
  long unsigned int D.22943;
  struct MonoInst * * D.22944;
  struct MonoInst * D.22945;
  struct MonoDebugVarInfo * D.22946;
  long unsigned int D.22947;
  struct MonoDebugVarInfo * D.22948;
  unsigned int i.0;
  unsigned int D.22950;
  long unsigned int D.22951;
  long unsigned int D.22952;
  void * D.22955;
  struct MonoInst * * D.22956;
  struct MonoInst * D.22957;
  struct MonoDebugVarInfo * D.22958;
  <unnamed-unsigned:1> D.22959;
  int D.22960;
  int D.22961;
  long unsigned int D.22962;
  long unsigned int D.22963;
  struct MonoInst * * D.22964;
  struct MonoInst * D.22965;
  struct MonoDebugVarInfo * D.22966;
  struct MonoDebugVarInfo * D.22967;
  struct MonoInst * D.22968;
  void * D.22971;
  void * D.22972;
  struct MonoDebugVarInfo * D.22973;
  struct MonoInst * D.22974;
  struct MonoDebugVarInfo * D.22975;
  struct GArray * D.22976;
  int D.22977;
  unsigned int D.22978;
  unsigned int D.22979;
  long unsigned int D.22980;
  long unsigned int D.22981;
  void * D.22982;
  struct MonoDebugLineNumberEntry * D.22983;
  struct MonoDebugLineNumberEntry * D.22984;
  gchar * D.22985;
  struct MonoDebugLineNumberEntry * D.22986;
  struct MonoMethod * D.22987;
  struct MonoDomain * D.22988;
  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.22922>; else goto <D.22924>;
  <D.22924>:
  D.22925 = info->jit;
  if (D.22925 == 0B) goto <D.22922>; else goto <D.22923>;
  <D.22922>:
  if (info != 0B) goto <D.22926>; else goto <D.22927>;
  <D.22926>:
  monoeg_g_free (info);
  <D.22927>:
  return;
  <D.22923>:
  method = cfg->method;
  header = cfg->header;
  sig = mono_method_signature (method);
  jit = info->jit;
  D.22928 = cfg->native_code;
  jit->code_start = D.22928;
  D.22929 = cfg->epilog_begin;
  jit->epilogue_begin = D.22929;
  D.22930 = cfg->code_len;
  jit->code_size = D.22930;
  D.22931 = jit->epilogue_begin;
  if (D.22931 != 0) goto <D.22932>; else goto <D.22933>;
  <D.22932>:
  D.22931 = jit->epilogue_begin;
  D.22934 = header->code_size;
  record_line_number (info, D.22931, D.22934);
  <D.22933>:
  D.22935 = sig->param_count;
  D.22936 = (unsigned int) D.22935;
  jit->num_params = D.22936;
  D.22937 = jit->num_params;
  D.22938 = (long unsigned int) D.22937;
  D.22939 = D.22938 * 32;
  D.22940 = monoeg_malloc0 (D.22939);
  jit->params = D.22940;
  i = 0;
  goto <D.22729>;
  <D.22728>:
  D.22941 = cfg->locals;
  D.22942 = (long unsigned int) i;
  D.22943 = D.22942 * 8;
  D.22944 = D.22941 + D.22943;
  D.22945 = *D.22944;
  D.22946 = jit->locals;
  D.22942 = (long unsigned int) i;
  D.22947 = D.22942 * 32;
  D.22948 = D.22946 + D.22947;
  write_variable (D.22945, D.22948);
  i = i + 1;
  <D.22729>:
  i.0 = (unsigned int) i;
  D.22950 = jit->num_locals;
  if (i.0 < D.22950) goto <D.22728>; else goto <D.22730>;
  <D.22730>:
  D.22951 = BIT_FIELD_REF <*sig, 64, 64>;
  D.22952 = D.22951 & 18014398509481984;
  if (D.22952 != 0) goto <D.22953>; else goto <D.22954>;
  <D.22953>:
  D.22955 = monoeg_malloc0 (32);
  jit->this_var = D.22955;
  D.22956 = cfg->args;
  D.22957 = *D.22956;
  D.22958 = jit->this_var;
  write_variable (D.22957, D.22958);
  <D.22954>:
  i = 0;
  goto <D.22732>;
  <D.22731>:
  D.22956 = cfg->args;
  D.22959 = sig->hasthis;
  D.22960 = (int) D.22959;
  D.22961 = D.22960 + i;
  D.22962 = (long unsigned int) D.22961;
  D.22963 = D.22962 * 8;
  D.22964 = D.22956 + D.22963;
  D.22965 = *D.22964;
  D.22966 = jit->params;
  D.22942 = (long unsigned int) i;
  D.22947 = D.22942 * 32;
  D.22967 = D.22966 + D.22947;
  write_variable (D.22965, D.22967);
  i = i + 1;
  <D.22732>:
  i.0 = (unsigned int) i;
  D.22937 = jit->num_params;
  if (i.0 < D.22937) goto <D.22731>; else goto <D.22733>;
  <D.22733>:
  D.22968 = cfg->gsharedvt_info_var;
  if (D.22968 != 0B) goto <D.22969>; else goto <D.22970>;
  <D.22969>:
  D.22971 = monoeg_malloc0 (32);
  jit->gsharedvt_info_var = D.22971;
  D.22972 = monoeg_malloc0 (32);
  jit->gsharedvt_locals_var = D.22972;
  D.22968 = cfg->gsharedvt_info_var;
  D.22973 = jit->gsharedvt_info_var;
  write_variable (D.22968, D.22973);
  D.22974 = cfg->gsharedvt_locals_var;
  D.22975 = jit->gsharedvt_locals_var;
  write_variable (D.22974, D.22975);
  <D.22970>:
  D.22976 = info->line_numbers;
  D.22977 = D.22976->len;
  D.22978 = (unsigned int) D.22977;
  jit->num_line_numbers = D.22978;
  D.22979 = jit->num_line_numbers;
  D.22980 = (long unsigned int) D.22979;
  D.22981 = D.22980 * 8;
  D.22982 = monoeg_malloc0 (D.22981);
  jit->line_numbers = D.22982;
  i = 0;
  goto <D.22735>;
  <D.22734>:
  D.22983 = jit->line_numbers;
  D.22942 = (long unsigned int) i;
  D.22943 = D.22942 * 8;
  D.22984 = D.22983 + D.22943;
  D.22976 = info->line_numbers;
  D.22985 = D.22976->data;
  D.22942 = (long unsigned int) i;
  D.22943 = D.22942 * 8;
  D.22986 = D.22985 + D.22943;
  *D.22984 = *D.22986;
  i = i + 1;
  <D.22735>:
  i.0 = (unsigned int) i;
  D.22979 = jit->num_line_numbers;
  if (i.0 < D.22979) goto <D.22734>; else goto <D.22736>;
  <D.22736>:
  D.22987 = cfg->method_to_register;
  D.22988 = cfg->domain;
  debug_info = mono_debug_add_method (D.22987, jit, D.22988);
  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.22990;
  struct MonoDebugLineNumberEntry lne;

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


write_variable (struct MonoInst * inst, struct MonoDebugVarInfo * var)
{
  struct MonoType * D.22991;
  short unsigned int D.22992;
  int D.22995;
  unsigned int D.22996;
  unsigned char D.22998;
  int D.22999;
  int D.23000;
  int D.23006;
  int D.23007;
  unsigned int D.23008;
  long int D.23009;
  unsigned int D.23010;
  int D.23014;
  unsigned int D.23015;
  long int D.23019;
  signed int D.23020;
  signed int D.23021;
  unsigned int D.23022;
  short unsigned int D.23026;
  _Bool D.23027;
  long int D.23028;
  long int D.23029;
  long int D.23032;
  unsigned int D.23033;
  int D.23034;
  int D.23035;
  unsigned int D.23036;

  D.22991 = inst->data.op[1].vtype;
  var->type = D.22991;
  D.22992 = inst->opcode;
  if (D.22992 == 366) goto <D.22993>; else goto <D.22994>;
  <D.22993>:
  D.22995 = inst->dreg;
  D.22996 = (unsigned int) D.22995;
  var->index = D.22996;
  goto <D.22997>;
  <D.22994>:
  D.22998 = inst->flags;
  D.22999 = (int) D.22998;
  D.23000 = D.22999 & 2;
  if (D.23000 != 0) goto <D.23001>; else goto <D.23002>;
  <D.23001>:
  var->index = 805306368;
  goto <D.23003>;
  <D.23002>:
  D.22992 = inst->opcode;
  if (D.22992 == 367) goto <D.23004>; else goto <D.23005>;
  <D.23004>:
  D.23006 = inst->sreg1;
  D.23007 = D.23006 | 268435456;
  D.23008 = (unsigned int) D.23007;
  var->index = D.23008;
  D.23009 = inst->data.op[0].const_val;
  D.23010 = (unsigned int) D.23009;
  var->offset = D.23010;
  goto <D.23011>;
  <D.23005>:
  D.22992 = inst->opcode;
  if (D.22992 == 332) goto <D.23012>; else goto <D.23013>;
  <D.23012>:
  D.23006 = inst->sreg1;
  D.23014 = D.23006 | 1073741824;
  D.23015 = (unsigned int) D.23014;
  var->index = D.23015;
  D.23009 = inst->data.op[0].const_val;
  D.23010 = (unsigned int) D.23009;
  var->offset = D.23010;
  goto <D.23016>;
  <D.23013>:
  D.22992 = inst->opcode;
  if (D.22992 == 331) goto <D.23017>; else goto <D.23018>;
  <D.23017>:
  D.23019 = inst->data.op[1].const_val;
  D.23020 = (signed int) D.23019;
  D.23021 = D.23020 | 1342177280;
  D.23022 = (unsigned int) D.23021;
  var->index = D.23022;
  goto <D.23023>;
  <D.23018>:
  D.22992 = inst->opcode;
  if (D.22992 == 368) goto <D.23024>; else goto <D.23025>;
  <D.23024>:
  {
    struct MonoInst * vtaddr;

    vtaddr = inst->data.op[0].src;
    D.23026 = vtaddr->opcode;
    D.23027 = D.23026 != 367;
    D.23028 = (long int) D.23027;
    D.23029 = __builtin_expect (D.23028, 0);
    if (D.23029 != 0) goto <D.23030>; else goto <D.23031>;
    <D.23030>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 107, "vtaddr->opcode == OP_REGOFFSET");
    <D.23031>:
    D.23032 = vtaddr->data.op[0].const_val;
    D.23033 = (unsigned int) D.23032;
    var->offset = D.23033;
    D.23034 = vtaddr->sreg1;
    D.23035 = D.23034 | 1610612736;
    D.23036 = (unsigned int) D.23035;
    var->index = D.23036;
  }
  goto <D.23037>;
  <D.23025>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 111);
  <D.23037>:
  <D.23023>:
  <D.23016>:
  <D.23011>:
  <D.23003>:
  <D.22997>:
}


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

}


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

  info = cfg->debug_info;
  if (info != 0B) goto <D.23038>; else goto <D.23039>;
  <D.23038>:
  D.23040 = info->line_numbers;
  if (D.23040 != 0B) goto <D.23041>; else goto <D.23042>;
  <D.23041>:
  D.23040 = info->line_numbers;
  monoeg_g_array_free (D.23040, 1);
  <D.23042>:
  monoeg_g_free (info);
  cfg->debug_info = 0B;
  <D.23039>:
}


mono_debug_record_line_number (struct MonoCompile * cfg, struct MonoInst * ins, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.23046;
  const unsigned char * D.23048;
  _Bool D.23049;
  long int D.23050;
  long int D.23051;
  const unsigned char * D.23056;
  unsigned int D.23058;
  sizetype D.23059;
  const unsigned char * D.23060;
  long int D.23061;
  long int D.23062;
  long int D.23063;
  unsigned int D.23064;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.23043>; else goto <D.23045>;
  <D.23045>:
  D.23046 = info->jit;
  if (D.23046 == 0B) goto <D.23043>; else goto <D.23047>;
  <D.23047>:
  D.23048 = ins->cil_code;
  if (D.23048 == 0B) goto <D.23043>; else goto <D.23044>;
  <D.23043>:
  return;
  <D.23044>:
  header = cfg->header;
  D.23049 = header == 0B;
  D.23050 = (long int) D.23049;
  D.23051 = __builtin_expect (D.23050, 0);
  if (D.23051 != 0) goto <D.23052>; else goto <D.23053>;
  <D.23052>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 308, "header");
  <D.23053>:
  D.23048 = ins->cil_code;
  D.23056 = header->code;
  if (D.23048 < D.23056) goto <D.23054>; else goto <D.23057>;
  <D.23057>:
  D.23048 = ins->cil_code;
  D.23056 = header->code;
  D.23058 = header->code_size;
  D.23059 = (sizetype) D.23058;
  D.23060 = D.23056 + D.23059;
  if (D.23048 > D.23060) goto <D.23054>; else goto <D.23055>;
  <D.23054>:
  return;
  <D.23055>:
  D.23048 = ins->cil_code;
  D.23061 = (long int) D.23048;
  D.23056 = header->code;
  D.23062 = (long int) D.23056;
  D.23063 = D.23061 - D.23062;
  offset = (guint32) D.23063;
  D.23064 = info->has_line_numbers;
  if (D.23064 == 0) goto <D.23065>; else goto <D.23066>;
  <D.23065>:
  D.23046 = info->jit;
  D.23046->prologue_end = address;
  info->has_line_numbers = 1;
  <D.23066>:
  record_line_number (info, address, offset);
}


mono_debug_open_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb, guint32 address)
{
  struct MonoDebugMethodJitInfo * D.23071;
  unsigned char * D.23073;
  _Bool D.23074;
  long int D.23075;
  long int D.23076;
  const unsigned char * D.23081;
  unsigned int D.23083;
  sizetype D.23084;
  const unsigned char * D.23085;
  long int D.23086;
  long int D.23087;
  long int D.23088;
  unsigned int D.23089;
  struct MiniDebugMethodInfo * info;
  struct MonoMethodHeader * header;
  guint32 offset;

  info = cfg->debug_info;
  if (info == 0B) goto <D.23068>; else goto <D.23070>;
  <D.23070>:
  D.23071 = info->jit;
  if (D.23071 == 0B) goto <D.23068>; else goto <D.23072>;
  <D.23072>:
  D.23073 = bb->cil_code;
  if (D.23073 == 0B) goto <D.23068>; else goto <D.23069>;
  <D.23068>:
  return;
  <D.23069>:
  header = cfg->header;
  D.23074 = header == 0B;
  D.23075 = (long int) D.23074;
  D.23076 = __builtin_expect (D.23075, 0);
  if (D.23076 != 0) goto <D.23077>; else goto <D.23078>;
  <D.23077>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 335, "header");
  <D.23078>:
  D.23073 = bb->cil_code;
  D.23081 = header->code;
  if (D.23073 < D.23081) goto <D.23079>; else goto <D.23082>;
  <D.23082>:
  D.23073 = bb->cil_code;
  D.23081 = header->code;
  D.23083 = header->code_size;
  D.23084 = (sizetype) D.23083;
  D.23085 = D.23081 + D.23084;
  if (D.23073 > D.23085) goto <D.23079>; else goto <D.23080>;
  <D.23079>:
  return;
  <D.23080>:
  D.23073 = bb->cil_code;
  D.23086 = (long int) D.23073;
  D.23081 = header->code;
  D.23087 = (long int) D.23081;
  D.23088 = D.23086 - D.23087;
  offset = (guint32) D.23088;
  D.23089 = info->has_line_numbers;
  if (D.23089 == 0) goto <D.23090>; else goto <D.23091>;
  <D.23090>:
  D.23071 = info->jit;
  D.23071->prologue_end = address;
  info->has_line_numbers = 1;
  <D.23091>:
  record_line_number (info, address, offset);
}


mono_debug_serialize_debug_info (struct MonoCompile * cfg, guint8 * * out_buf, guint32 * buf_len)
{
  struct MonoMethod * D.23093;
  struct MonoDomain * D.23094;
  unsigned int D.23097;
  unsigned int D.23098;
  unsigned int D.23099;
  unsigned int D.23100;
  unsigned int D.23101;
  unsigned int D.23102;
  unsigned int D.23103;
  long unsigned int D.23104;
  unsigned int D.23105;
  int D.23106;
  guint8 * p.1;
  unsigned int D.23108;
  int D.23109;
  unsigned int D.23110;
  int D.23111;
  struct MonoDebugVarInfo * D.23112;
  long unsigned int D.23113;
  long unsigned int D.23114;
  struct MonoDebugVarInfo * D.23115;
  unsigned int i.2;
  struct MonoMethodSignature * D.23117;
  long unsigned int D.23118;
  long unsigned int D.23119;
  struct MonoDebugVarInfo * D.23122;
  struct MonoDebugVarInfo * D.23123;
  struct MonoDebugVarInfo * D.23124;
  struct MonoDebugVarInfo * D.23125;
  struct MonoDebugVarInfo * D.23128;
  int D.23130;
  struct MonoDebugLineNumberEntry * D.23131;
  long unsigned int D.23132;
  unsigned int D.23133;
  unsigned int D.23134;
  int D.23135;
  unsigned int D.23136;
  unsigned int D.23137;
  int D.23138;
  long int p.3;
  long int buf.4;
  long int D.23141;
  long int D.23142;
  _Bool D.23143;
  long int D.23144;
  long int D.23145;
  unsigned int D.23148;
  struct MonoDebugMethodJitInfo * jit;
  guint32 size;
  guint32 prev_offset;
  guint32 prev_native_offset;
  guint8 * buf;
  guint8 * p;
  int i;

  try
    {
      D.23093 = cfg->method;
      D.23094 = mono_domain_get ();
      jit = mono_debug_find_method (D.23093, D.23094);
      if (jit == 0B) goto <D.23095>; else goto <D.23096>;
      <D.23095>:
      *buf_len = 0;
      return;
      <D.23096>:
      D.23097 = jit->num_params;
      D.23098 = jit->num_locals;
      D.23099 = D.23097 + D.23098;
      D.23100 = jit->num_line_numbers;
      D.23101 = D.23099 + D.23100;
      D.23102 = D.23101 + 1;
      D.23103 = D.23102 * 10;
      size = D.23103 + 64;
      D.23104 = (long unsigned int) size;
      buf = monoeg_malloc (D.23104);
      p = buf;
      D.23105 = jit->epilogue_begin;
      D.23106 = (int) D.23105;
      p.1 = p;
      encode_value (D.23106, p.1, &p);
      D.23108 = jit->prologue_end;
      D.23109 = (int) D.23108;
      p.1 = p;
      encode_value (D.23109, p.1, &p);
      D.23110 = jit->code_size;
      D.23111 = (int) D.23110;
      p.1 = p;
      encode_value (D.23111, p.1, &p);
      i = 0;
      goto <D.22796>;
      <D.22795>:
      D.23112 = jit->params;
      D.23113 = (long unsigned int) i;
      D.23114 = D.23113 * 32;
      D.23115 = D.23112 + D.23114;
      p.1 = p;
      serialize_variable (D.23115, p.1, &p);
      i = i + 1;
      <D.22796>:
      i.2 = (unsigned int) i;
      D.23097 = jit->num_params;
      if (i.2 < D.23097) goto <D.22795>; else goto <D.22797>;
      <D.22797>:
      D.23093 = cfg->method;
      D.23117 = mono_method_signature (D.23093);
      D.23118 = BIT_FIELD_REF <*D.23117, 64, 64>;
      D.23119 = D.23118 & 18014398509481984;
      if (D.23119 != 0) goto <D.23120>; else goto <D.23121>;
      <D.23120>:
      D.23122 = jit->this_var;
      p.1 = p;
      serialize_variable (D.23122, p.1, &p);
      <D.23121>:
      i = 0;
      goto <D.22799>;
      <D.22798>:
      D.23123 = jit->locals;
      D.23113 = (long unsigned int) i;
      D.23114 = D.23113 * 32;
      D.23124 = D.23123 + D.23114;
      p.1 = p;
      serialize_variable (D.23124, p.1, &p);
      i = i + 1;
      <D.22799>:
      i.2 = (unsigned int) i;
      D.23098 = jit->num_locals;
      if (i.2 < D.23098) goto <D.22798>; else goto <D.22800>;
      <D.22800>:
      D.23125 = jit->gsharedvt_info_var;
      if (D.23125 != 0B) goto <D.23126>; else goto <D.23127>;
      <D.23126>:
      p.1 = p;
      encode_value (1, p.1, &p);
      D.23125 = jit->gsharedvt_info_var;
      p.1 = p;
      serialize_variable (D.23125, p.1, &p);
      D.23128 = jit->gsharedvt_locals_var;
      p.1 = p;
      serialize_variable (D.23128, p.1, &p);
      goto <D.23129>;
      <D.23127>:
      p.1 = p;
      encode_value (0, p.1, &p);
      <D.23129>:
      D.23100 = jit->num_line_numbers;
      D.23130 = (int) D.23100;
      p.1 = p;
      encode_value (D.23130, p.1, &p);
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22803>;
      <D.22802>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.23131 = jit->line_numbers;
        D.23113 = (long unsigned int) i;
        D.23132 = D.23113 * 8;
        lne = D.23131 + D.23132;
        D.23133 = lne->il_offset;
        D.23134 = D.23133 - prev_offset;
        D.23135 = (int) D.23134;
        p.1 = p;
        encode_value (D.23135, p.1, &p);
        D.23136 = lne->native_offset;
        D.23137 = D.23136 - prev_native_offset;
        D.23138 = (int) D.23137;
        p.1 = p;
        encode_value (D.23138, p.1, &p);
        prev_offset = lne->il_offset;
        prev_native_offset = lne->native_offset;
      }
      i = i + 1;
      <D.22803>:
      i.2 = (unsigned int) i;
      D.23100 = jit->num_line_numbers;
      if (i.2 < D.23100) goto <D.22802>; else goto <D.22804>;
      <D.22804>:
      p.1 = p;
      p.3 = (long int) p.1;
      buf.4 = (long int) buf;
      D.23141 = p.3 - buf.4;
      D.23142 = (long int) size;
      D.23143 = D.23141 >= D.23142;
      D.23144 = (long int) D.23143;
      D.23145 = __builtin_expect (D.23144, 0);
      if (D.23145 != 0) goto <D.23146>; else goto <D.23147>;
      <D.23146>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 491, "p - buf < size");
      <D.23147>:
      *out_buf = buf;
      p.1 = p;
      p.3 = (long int) p.1;
      buf.4 = (long int) buf;
      D.23141 = p.3 - buf.4;
      D.23148 = (unsigned int) D.23141;
      *buf_len = D.23148;
    }
  finally
    {
      p = {CLOBBER};
    }
}


serialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  unsigned int D.23152;
  int D.23153;
  guint8 * p.5;
  unsigned int D.23155;
  int D.23156;
  guint32 flags;

  D.23152 = var->index;
  flags = D.23152 & 4026531840;
  D.23152 = var->index;
  D.23153 = (int) D.23152;
  p.5 = p;
  encode_value (D.23153, p.5, &p);
  switch (flags) <default: <D.22782>, case 0: <D.22775>, case 268435456: <D.22777>, case 805306368: <D.22781>, case 1073741824: <D.22778>, case 1342177280: <D.22779>, case 1610612736: <D.22780>>
  <D.22775>:
  goto <D.22776>;
  <D.22777>:
  <D.22778>:
  D.23155 = var->offset;
  D.23156 = (int) D.23155;
  p.5 = p;
  encode_value (D.23156, p.5, &p);
  goto <D.22776>;
  <D.22779>:
  <D.22780>:
  <D.22781>:
  goto <D.22776>;
  <D.22782>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 435);
  <D.22776>:
  p.5 = p;
  *endbuf = p.5;
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.6;
  guint8 * p.7;
  unsigned char D.23162;
  int D.23166;
  signed char D.23167;
  signed char D.23168;
  unsigned char D.23169;
  guint8 * D.23170;
  unsigned char D.23171;
  int D.23175;
  signed char D.23176;
  signed char D.23177;
  unsigned char D.23178;
  int D.23179;
  unsigned char D.23180;
  guint8 * D.23181;
  unsigned char D.23182;
  guint8 * D.23183;
  unsigned int D.23185;
  unsigned char D.23186;
  guint8 * D.23187;
  guint8 * p;

  p = buf;
  value.6 = (unsigned int) value;
  if (value.6 <= 127) goto <D.23159>; else goto <D.23160>;
  <D.23159>:
  p.7 = p;
  p = p.7 + 1;
  D.23162 = (unsigned char) value;
  *p.7 = D.23162;
  goto <D.23163>;
  <D.23160>:
  value.6 = (unsigned int) value;
  if (value.6 <= 16383) goto <D.23164>; else goto <D.23165>;
  <D.23164>:
  D.23166 = value >> 8;
  D.23167 = (signed char) D.23166;
  D.23168 = D.23167 | -128;
  D.23169 = (unsigned char) D.23168;
  *p = D.23169;
  D.23170 = p + 1;
  D.23171 = (unsigned char) value;
  *D.23170 = D.23171;
  p = p + 2;
  goto <D.23172>;
  <D.23165>:
  value.6 = (unsigned int) value;
  if (value.6 <= 536870911) goto <D.23173>; else goto <D.23174>;
  <D.23173>:
  D.23175 = value >> 24;
  D.23176 = (signed char) D.23175;
  D.23177 = D.23176 | -64;
  D.23178 = (unsigned char) D.23177;
  *p = D.23178;
  D.23170 = p + 1;
  D.23179 = value >> 16;
  D.23180 = (unsigned char) D.23179;
  *D.23170 = D.23180;
  D.23181 = p + 2;
  D.23166 = value >> 8;
  D.23182 = (unsigned char) D.23166;
  *D.23181 = D.23182;
  D.23183 = p + 3;
  D.23171 = (unsigned char) value;
  *D.23183 = D.23171;
  p = p + 4;
  goto <D.23184>;
  <D.23174>:
  *p = 255;
  D.23170 = p + 1;
  value.6 = (unsigned int) value;
  D.23185 = value.6 >> 24;
  D.23186 = (unsigned char) D.23185;
  *D.23170 = D.23186;
  D.23181 = p + 2;
  D.23179 = value >> 16;
  D.23180 = (unsigned char) D.23179;
  *D.23181 = D.23180;
  D.23183 = p + 3;
  D.23166 = value >> 8;
  D.23182 = (unsigned char) D.23166;
  *D.23183 = D.23182;
  D.23187 = p + 4;
  D.23171 = (unsigned char) value;
  *D.23187 = D.23171;
  p = p + 5;
  <D.23184>:
  <D.23172>:
  <D.23163>:
  if (endbuf != 0B) goto <D.23188>; else goto <D.23189>;
  <D.23188>:
  *endbuf = p;
  <D.23189>:
}


mono_debug_add_aot_method (struct MonoDomain * domain, struct MonoMethod * method, guint8 * code_start, guint8 * debug_info, guint32 debug_info_len)
{
  int D.23190;
  short unsigned int D.23195;
  unsigned int D.23196;
  unsigned int D.23197;
  short unsigned int D.23199;
  unsigned int D.23200;
  unsigned int D.23201;
  long unsigned int D.23203;
  long unsigned int D.23204;
  struct MonoDebugMethodJitInfo * jit;

  D.23190 = mono_debug_enabled ();
  if (D.23190 == 0) goto <D.23191>; else goto <D.23192>;
  <D.23191>:
  return;
  <D.23192>:
  D.23195 = method->iflags;
  D.23196 = (unsigned int) D.23195;
  D.23197 = D.23196 & 4099;
  if (D.23197 != 0) goto <D.23193>; else goto <D.23198>;
  <D.23198>:
  D.23199 = method->flags;
  D.23200 = (unsigned int) D.23199;
  D.23201 = D.23200 & 9216;
  if (D.23201 != 0) goto <D.23193>; else goto <D.23202>;
  <D.23202>:
  D.23203 = BIT_FIELD_REF <*method, 64, 256>;
  D.23204 = D.23203 & 124;
  if (D.23204 != 0) goto <D.23193>; else goto <D.23194>;
  <D.23193>:
  return;
  <D.23194>:
  if (debug_info_len == 0) goto <D.23205>; else goto <D.23206>;
  <D.23205>:
  return;
  <D.23206>:
  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.23208;
  long int D.23209;
  long int D.23210;
  short unsigned int D.23213;
  unsigned int D.23214;
  unsigned int D.23215;
  long unsigned int D.23216;
  long unsigned int D.23217;
  void * D.23218;
  struct MonoMethodSignature * D.23219;
  short unsigned int D.23220;
  unsigned int D.23221;
  unsigned int D.23222;
  long unsigned int D.23223;
  long unsigned int D.23224;
  void * D.23225;
  guint8 * p.8;
  int D.23227;
  unsigned int D.23228;
  int D.23229;
  unsigned int D.23230;
  int D.23231;
  unsigned int D.23232;
  struct MonoDebugVarInfo * D.23233;
  long unsigned int D.23234;
  long unsigned int D.23235;
  struct MonoDebugVarInfo * D.23236;
  unsigned int i.9;
  struct MonoMethodSignature * D.23238;
  long unsigned int D.23239;
  long unsigned int D.23240;
  void * D.23243;
  struct MonoDebugVarInfo * D.23244;
  struct MonoDebugVarInfo * D.23245;
  struct MonoDebugVarInfo * D.23246;
  int D.23247;
  void * D.23250;
  void * D.23251;
  struct MonoDebugVarInfo * D.23252;
  struct MonoDebugVarInfo * D.23253;
  int D.23254;
  unsigned int D.23255;
  unsigned int D.23256;
  long unsigned int D.23257;
  long unsigned int D.23258;
  void * D.23259;
  struct MonoDebugLineNumberEntry * D.23260;
  long unsigned int D.23261;
  int D.23262;
  int D.23263;
  unsigned int native_offset.10;
  unsigned int offset.11;
  struct MonoDebugMethodJitInfo * D.23266;
  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.23208 = header == 0B;
      D.23209 = (long int) D.23208;
      D.23210 = __builtin_expect (D.23209, 0);
      if (D.23210 != 0) goto <D.23211>; else goto <D.23212>;
      <D.23211>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-mini.c", 533, "header");
      <D.23212>:
      jit = monoeg_malloc0 (104);
      jit->code_start = code_start;
      D.23213 = header->num_locals;
      D.23214 = (unsigned int) D.23213;
      jit->num_locals = D.23214;
      D.23215 = jit->num_locals;
      D.23216 = (long unsigned int) D.23215;
      D.23217 = D.23216 * 32;
      D.23218 = monoeg_malloc0 (D.23217);
      jit->locals = D.23218;
      D.23219 = mono_method_signature (method);
      D.23220 = D.23219->param_count;
      D.23221 = (unsigned int) D.23220;
      jit->num_params = D.23221;
      D.23222 = jit->num_params;
      D.23223 = (long unsigned int) D.23222;
      D.23224 = D.23223 * 32;
      D.23225 = monoeg_malloc0 (D.23224);
      jit->params = D.23225;
      p = buf;
      p.8 = p;
      D.23227 = decode_value (p.8, &p);
      D.23228 = (unsigned int) D.23227;
      jit->epilogue_begin = D.23228;
      p.8 = p;
      D.23229 = decode_value (p.8, &p);
      D.23230 = (unsigned int) D.23229;
      jit->prologue_end = D.23230;
      p.8 = p;
      D.23231 = decode_value (p.8, &p);
      D.23232 = (unsigned int) D.23231;
      jit->code_size = D.23232;
      i = 0;
      goto <D.22834>;
      <D.22833>:
      D.23233 = jit->params;
      D.23234 = (long unsigned int) i;
      D.23235 = D.23234 * 32;
      D.23236 = D.23233 + D.23235;
      p.8 = p;
      deserialize_variable (D.23236, p.8, &p);
      i = i + 1;
      <D.22834>:
      i.9 = (unsigned int) i;
      D.23222 = jit->num_params;
      if (i.9 < D.23222) goto <D.22833>; else goto <D.22835>;
      <D.22835>:
      D.23238 = mono_method_signature (method);
      D.23239 = BIT_FIELD_REF <*D.23238, 64, 64>;
      D.23240 = D.23239 & 18014398509481984;
      if (D.23240 != 0) goto <D.23241>; else goto <D.23242>;
      <D.23241>:
      D.23243 = monoeg_malloc0 (32);
      jit->this_var = D.23243;
      D.23244 = jit->this_var;
      p.8 = p;
      deserialize_variable (D.23244, p.8, &p);
      <D.23242>:
      i = 0;
      goto <D.22837>;
      <D.22836>:
      D.23245 = jit->locals;
      D.23234 = (long unsigned int) i;
      D.23235 = D.23234 * 32;
      D.23246 = D.23245 + D.23235;
      p.8 = p;
      deserialize_variable (D.23246, p.8, &p);
      i = i + 1;
      <D.22837>:
      i.9 = (unsigned int) i;
      D.23215 = jit->num_locals;
      if (i.9 < D.23215) goto <D.22836>; else goto <D.22838>;
      <D.22838>:
      p.8 = p;
      D.23247 = decode_value (p.8, &p);
      if (D.23247 != 0) goto <D.23248>; else goto <D.23249>;
      <D.23248>:
      D.23250 = monoeg_malloc0 (32);
      jit->gsharedvt_info_var = D.23250;
      D.23251 = monoeg_malloc0 (32);
      jit->gsharedvt_locals_var = D.23251;
      D.23252 = jit->gsharedvt_info_var;
      p.8 = p;
      deserialize_variable (D.23252, p.8, &p);
      D.23253 = jit->gsharedvt_locals_var;
      p.8 = p;
      deserialize_variable (D.23253, p.8, &p);
      <D.23249>:
      p.8 = p;
      D.23254 = decode_value (p.8, &p);
      D.23255 = (unsigned int) D.23254;
      jit->num_line_numbers = D.23255;
      D.23256 = jit->num_line_numbers;
      D.23257 = (long unsigned int) D.23256;
      D.23258 = D.23257 * 8;
      D.23259 = monoeg_malloc0 (D.23258);
      jit->line_numbers = D.23259;
      prev_offset = 0;
      prev_native_offset = 0;
      i = 0;
      goto <D.22841>;
      <D.22840>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.23260 = jit->line_numbers;
        D.23234 = (long unsigned int) i;
        D.23261 = D.23234 * 8;
        lne = D.23260 + D.23261;
        p.8 = p;
        D.23262 = decode_value (p.8, &p);
        offset = D.23262 + prev_offset;
        p.8 = p;
        D.23263 = decode_value (p.8, &p);
        native_offset = D.23263 + 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.22841>:
      i.9 = (unsigned int) i;
      D.23256 = jit->num_line_numbers;
      if (i.9 < D.23256) goto <D.22840>; else goto <D.22842>;
      <D.22842>:
      mono_metadata_free_mh (header);
      D.23266 = jit;
      return D.23266;
    }
  finally
    {
      p = {CLOBBER};
    }
}


deserialize_variable (struct MonoDebugVarInfo * var, guint8 * p, guint8 * * endbuf)
{
  guint8 * p.12;
  int D.23270;
  unsigned int D.23271;
  unsigned int D.23272;
  int D.23273;
  unsigned int D.23274;
  guint32 flags;

  p.12 = p;
  D.23270 = decode_value (p.12, &p);
  D.23271 = (unsigned int) D.23270;
  var->index = D.23271;
  D.23272 = var->index;
  flags = D.23272 & 4026531840;
  switch (flags) <default: <D.22818>, case 0: <D.22811>, case 268435456: <D.22813>, case 805306368: <D.22817>, case 1073741824: <D.22814>, case 1342177280: <D.22815>, case 1610612736: <D.22816>>
  <D.22811>:
  goto <D.22812>;
  <D.22813>:
  <D.22814>:
  p.12 = p;
  D.23273 = decode_value (p.12, &p);
  D.23274 = (unsigned int) D.23273;
  var->offset = D.23274;
  goto <D.22812>;
  <D.22815>:
  <D.22816>:
  <D.22817>:
  goto <D.22812>;
  <D.22818>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 518);
  <D.22812>:
  p.12 = p;
  *endbuf = p.12;
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.13;
  int D.23280;
  int D.23281;
  int D.23284;
  int D.23285;
  guint8 * D.23286;
  unsigned char D.23287;
  int D.23288;
  int D.23292;
  int D.23293;
  int D.23294;
  int D.23295;
  guint8 * D.23296;
  unsigned char D.23297;
  int D.23298;
  int D.23299;
  int D.23300;
  guint8 * D.23301;
  unsigned char D.23302;
  int D.23303;
  int D.23305;
  int D.23306;
  int D.23307;
  int D.23308;
  int D.23309;
  guint8 * D.23310;
  unsigned char D.23311;
  int D.23312;
  gint32 D.23315;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.13 = (signed char) b;
  if (b.13 >= 0) goto <D.23277>; else goto <D.23278>;
  <D.23277>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.23279>;
  <D.23278>:
  D.23280 = (int) b;
  D.23281 = D.23280 & 64;
  if (D.23281 == 0) goto <D.23282>; else goto <D.23283>;
  <D.23282>:
  D.23280 = (int) b;
  D.23284 = D.23280 & 63;
  D.23285 = D.23284 << 8;
  D.23286 = ptr + 1;
  D.23287 = *D.23286;
  D.23288 = (int) D.23287;
  len = D.23285 | D.23288;
  ptr = ptr + 2;
  goto <D.23289>;
  <D.23283>:
  if (b != 255) goto <D.23290>; else goto <D.23291>;
  <D.23290>:
  D.23280 = (int) b;
  D.23292 = D.23280 & 31;
  D.23293 = D.23292 << 24;
  D.23286 = ptr + 1;
  D.23287 = *D.23286;
  D.23288 = (int) D.23287;
  D.23294 = D.23288 << 16;
  D.23295 = D.23293 | D.23294;
  D.23296 = ptr + 2;
  D.23297 = *D.23296;
  D.23298 = (int) D.23297;
  D.23299 = D.23298 << 8;
  D.23300 = D.23295 | D.23299;
  D.23301 = ptr + 3;
  D.23302 = *D.23301;
  D.23303 = (int) D.23302;
  len = D.23300 | D.23303;
  ptr = ptr + 4;
  goto <D.23304>;
  <D.23291>:
  D.23286 = ptr + 1;
  D.23287 = *D.23286;
  D.23288 = (int) D.23287;
  D.23305 = D.23288 << 24;
  D.23296 = ptr + 2;
  D.23297 = *D.23296;
  D.23298 = (int) D.23297;
  D.23306 = D.23298 << 16;
  D.23307 = D.23305 | D.23306;
  D.23301 = ptr + 3;
  D.23302 = *D.23301;
  D.23303 = (int) D.23302;
  D.23308 = D.23303 << 8;
  D.23309 = D.23307 | D.23308;
  D.23310 = ptr + 4;
  D.23311 = *D.23310;
  D.23312 = (int) D.23311;
  len = D.23309 | D.23312;
  ptr = ptr + 5;
  <D.23304>:
  <D.23289>:
  <D.23279>:
  if (rptr != 0B) goto <D.23313>; else goto <D.23314>;
  <D.23313>:
  *rptr = ptr;
  <D.23314>:
  D.23315 = len;
  return D.23315;
}


mono_debug_print_vars (void * ip, gboolean only_arguments)
{
  struct MonoMethod * D.23319;
  unsigned int D.23324;
  long unsigned int D.23325;
  long unsigned int D.23326;
  struct MonoMethod * D.23327;
  struct MonoDebugVarInfo * D.23328;
  struct MonoDebugVarInfo * D.23331;
  long unsigned int D.23332;
  long unsigned int D.23333;
  struct MonoDebugVarInfo * D.23334;
  const char * iftmp.14;
  long unsigned int D.23336;
  char * * D.23337;
  char * D.23338;
  unsigned int i.15;
  struct MonoDebugVarInfo * D.23344;
  struct MonoDebugVarInfo * D.23345;
  unsigned int D.23346;
  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.23317>; else goto <D.23318>;
  <D.23317>:
  return;
  <D.23318>:
  D.23319 = jinfo_get_method (ji);
  jit = mono_debug_find_method (D.23319, domain);
  if (jit == 0B) goto <D.23320>; else goto <D.23321>;
  <D.23320>:
  return;
  <D.23321>:
  if (only_arguments != 0) goto <D.23322>; else goto <D.23323>;
  <D.23322>:
  {
    char * * names;

    D.23324 = jit->num_params;
    D.23325 = (long unsigned int) D.23324;
    D.23326 = D.23325 * 8;
    names = monoeg_malloc (D.23326);
    D.23327 = jinfo_get_method (ji);
    mono_method_get_param_names (D.23327, names);
    D.23328 = jit->this_var;
    if (D.23328 != 0B) goto <D.23329>; else goto <D.23330>;
    <D.23329>:
    D.23328 = jit->this_var;
    print_var_info (D.23328, 0, "this", "Arg");
    <D.23330>:
    i = 0;
    goto <D.22875>;
    <D.22874>:
    D.23331 = jit->params;
    D.23332 = (long unsigned int) i;
    D.23333 = D.23332 * 32;
    D.23334 = D.23331 + D.23333;
    D.23332 = (long unsigned int) i;
    D.23336 = D.23332 * 8;
    D.23337 = names + D.23336;
    D.23338 = *D.23337;
    if (D.23338 != 0B) goto <D.23339>; else goto <D.23340>;
    <D.23339>:
    D.23332 = (long unsigned int) i;
    D.23336 = D.23332 * 8;
    D.23337 = names + D.23336;
    iftmp.14 = *D.23337;
    goto <D.23341>;
    <D.23340>:
    iftmp.14 = "unknown name";
    <D.23341>:
    print_var_info (D.23334, i, iftmp.14, "Arg");
    i = i + 1;
    <D.22875>:
    i.15 = (unsigned int) i;
    D.23324 = jit->num_params;
    if (i.15 < D.23324) goto <D.22874>; else goto <D.22876>;
    <D.22876>:
    monoeg_g_free (names);
  }
  goto <D.23343>;
  <D.23323>:
  i = 0;
  goto <D.22878>;
  <D.22877>:
  D.23344 = jit->locals;
  D.23332 = (long unsigned int) i;
  D.23333 = D.23332 * 32;
  D.23345 = D.23344 + D.23333;
  print_var_info (D.23345, i, "", "Local");
  i = i + 1;
  <D.22878>:
  i.15 = (unsigned int) i;
  D.23346 = jit->num_locals;
  if (i.15 < D.23346) goto <D.22877>; else goto <D.22879>;
  <D.22879>:
  <D.23343>:
  mono_debug_free_method_jit_info (jit);
}


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

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


print_var_info (struct MonoDebugVarInfo * info, int idx, const char * name, const char * type)
{
  unsigned int D.23350;
  unsigned int D.23351;
  int D.23352;
  int D.23353;
  const char * D.23354;
  const char * D.23355;
  unsigned int D.23356;
  const char * D.23357;
  const char * D.23358;

  D.23350 = info->index;
  D.23351 = D.23350 & 4026531840;
  switch (D.23351) <default: <D.22864>, case 0: <D.22857>, case 268435456: <D.22859>, case 536870912: <D.22863>, case 1073741824: <D.22860>, case 1342177280: <D.22861>, case 1610612736: <D.22862>>
  <D.22857>:
  D.23350 = info->index;
  D.23352 = (int) D.23350;
  D.23353 = D.23352 & 268435455;
  D.23354 = mono_arch_regname (D.23353);
  monoeg_g_print ("%s %s (%d) in register %s\n", type, name, idx, D.23354);
  goto <D.22858>;
  <D.22859>:
  D.23350 = info->index;
  D.23352 = (int) D.23350;
  D.23353 = D.23352 & 268435455;
  D.23355 = mono_arch_regname (D.23353);
  D.23356 = info->offset;
  monoeg_g_print ("%s %s (%d) in memory: base register %s + %d\n", type, name, idx, D.23355, D.23356);
  goto <D.22858>;
  <D.22860>:
  D.23350 = info->index;
  D.23352 = (int) D.23350;
  D.23353 = D.23352 & 268435455;
  D.23357 = mono_arch_regname (D.23353);
  D.23356 = info->offset;
  monoeg_g_print ("%s %s (%d) in indir memory: base register %s + %d\n", type, name, idx, D.23357, D.23356);
  goto <D.22858>;
  <D.22861>:
  monoeg_g_print ("%s %s (%d) gsharedvt local.\n", type, name, idx);
  goto <D.22858>;
  <D.22862>:
  D.23350 = info->index;
  D.23352 = (int) D.23350;
  D.23353 = D.23352 & 268435455;
  D.23358 = mono_arch_regname (D.23353);
  D.23356 = info->offset;
  monoeg_g_print ("%s %s (%d) vt address: base register %s + %d\n", type, name, idx, D.23358, D.23356);
  goto <D.22858>;
  <D.22863>:
  <D.22864>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mini.c", 636);
  <D.22858>:
}


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

  desc = mono_method_desc_new (method_name, include_namespace);
  if (desc == 0B) goto <D.23359>; else goto <D.23360>;
  <D.23359>:
  D.23361 = 0;
  return D.23361;
  <D.23360>:
  D.23361 = mono_debugger_insert_breakpoint_full (desc);
  return D.23361;
}


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.23370;
  unsigned int D.23371;
  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.23367>; else goto <D.23368>;
  <D.23367>:
  breakpoints.20 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.20;
  <D.23368>:
  breakpoints.19 = breakpoints;
  monoeg_g_ptr_array_add (breakpoints.19, info);
  D.23371 = info->index;
  D.23370 = (int) D.23371;
  return D.23370;
}


mono_debugger_method_has_breakpoint (struct MonoMethod * method)
{
  struct GPtrArray * breakpoints.21;
  int D.23376;
  void * * D.23377;
  long unsigned int D.23378;
  long unsigned int D.23379;
  void * * D.23380;
  struct MonoMethodDesc * D.23381;
  int D.23382;
  unsigned int D.23385;
  unsigned int i.22;
  unsigned int D.23387;
  int i;

  breakpoints.21 = breakpoints;
  if (breakpoints.21 == 0B) goto <D.23374>; else goto <D.23375>;
  <D.23374>:
  D.23376 = 0;
  return D.23376;
  <D.23375>:
  i = 0;
  goto <D.22898>;
  <D.22897>:
  {
    struct MiniDebugBreakpointInfo * info;

    breakpoints.21 = breakpoints;
    D.23377 = breakpoints.21->pdata;
    D.23378 = (long unsigned int) i;
    D.23379 = D.23378 * 8;
    D.23380 = D.23377 + D.23379;
    info = *D.23380;
    D.23381 = info->desc;
    D.23382 = mono_method_desc_full_match (D.23381, method);
    if (D.23382 == 0) goto <D.23383>; else goto <D.23384>;
    <D.23383>:
    // predicted unlikely by continue predictor.
    goto <D.22896>;
    <D.23384>:
    D.23385 = info->index;
    D.23376 = (int) D.23385;
    return D.23376;
  }
  <D.22896>:
  i = i + 1;
  <D.22898>:
  i.22 = (unsigned int) i;
  breakpoints.21 = breakpoints;
  D.23387 = breakpoints.21->len;
  if (i.22 < D.23387) goto <D.22897>; else goto <D.22899>;
  <D.22899>:
  D.23376 = 0;
  return D.23376;
}