mono_mb_new_no_dup_name (struct MonoClass * klass, const char * name, MonoWrapperType type)
{
  struct MonoMethodBuilder * D.16703;
  struct MonoMethodBuilder * mb;

  mb = mono_mb_new_base (klass, type);
  mb->name = name;
  mb->no_dup_name = 1;
  D.16703 = mb;
  return D.16703;
}


mono_mb_new_base (struct MonoClass * klass, MonoWrapperType type)
{
  _Bool D.16705;
  long int D.16706;
  long int D.16707;
  unsigned char D.16710;
  <unnamed-unsigned:5> D.16711;
  unsigned int D.16712;
  void * D.16713;
  struct MonoMethodBuilder * D.16714;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * m;

  D.16705 = klass == 0B;
  D.16706 = (long int) D.16705;
  D.16707 = __builtin_expect (D.16706, 0);
  if (D.16707 != 0) goto <D.16708>; else goto <D.16709>;
  <D.16708>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 57, "klass != NULL");
  <D.16709>:
  mb = monoeg_malloc0 (52);
  m = monoeg_malloc0 (32);
  mb->method = m;
  m->klass = klass;
  m->inline_info = 1;
  D.16710 = (unsigned char) type;
  D.16711 = (<unnamed-unsigned:5>) D.16710;
  m->wrapper_type = D.16711;
  mb->code_size = 40;
  D.16712 = mb->code_size;
  D.16713 = monoeg_malloc (D.16712);
  mb->code = D.16713;
  mono_mb_add_data (mb, 0B);
  D.16714 = mb;
  return D.16714;
}


mono_mb_new (struct MonoClass * klass, const char * name, MonoWrapperType type)
{
  gchar * D.16716;
  struct MonoMethodBuilder * D.16717;
  struct MonoMethodBuilder * mb;

  mb = mono_mb_new_base (klass, type);
  D.16716 = monoeg_strdup (name);
  mb->name = D.16716;
  D.16717 = mb;
  return D.16717;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.16721;

  if (str != 0B) goto <D.16719>; else goto <D.16720>;
  <D.16719>:
  D.16721 = __strdup (str);
  return D.16721;
  <D.16720>:
  D.16721 = 0B;
  return D.16721;
}


mono_mb_free (struct MonoMethodBuilder * mb)
{
  struct GList * D.16723;
  int D.16724;
  struct MonoMethod * D.16727;
  int D.16728;
  char * D.16731;
  unsigned char * D.16732;

  D.16723 = mb->locals_list;
  monoeg_g_list_free (D.16723);
  D.16724 = mb->dynamic;
  if (D.16724 == 0) goto <D.16725>; else goto <D.16726>;
  <D.16725>:
  D.16727 = mb->method;
  monoeg_g_free (D.16727);
  D.16728 = mb->no_dup_name;
  if (D.16728 == 0) goto <D.16729>; else goto <D.16730>;
  <D.16729>:
  D.16731 = mb->name;
  monoeg_g_free (D.16731);
  <D.16730>:
  D.16732 = mb->code;
  monoeg_g_free (D.16732);
  <D.16726>:
  monoeg_g_free (mb);
}


mono_mb_create_method (struct MonoMethodBuilder * mb, struct MonoMethodSignature * signature, int max_stack)
{
  _Bool D.16733;
  long int D.16734;
  long int D.16735;
  struct MonoMethod * D.16738;
  struct MonoClass * D.16739;
  int D.16740;
  char * D.16743;
  int D.16744;
  unsigned int D.16745;
  unsigned int D.16746;
  unsigned int D.16747;
  unsigned char * D.16748;
  void * D.16749;
  struct MonoType * D.16750;
  int D.16752;
  char * D.16756;
  unsigned int D.16757;
  void * D.16758;
  const unsigned char * D.16759;
  unsigned int D.16760;
  unsigned int D.16761;
  short unsigned int D.16764;
  short unsigned int D.16765;
  short unsigned int D.16768;
  <unnamed-unsigned:15> D.16769;
  short unsigned int D.16770;
  int D.16771;
  short unsigned int D.16772;
  <unnamed-unsigned:15> D.16773;
  struct MonoExceptionClause * D.16774;
  int D.16775;
  unsigned char D.16776;
  <unnamed-unsigned:1> D.16777;
  void * D.16778;
  unsigned int D.16779;
  unsigned int D.16782;
  unsigned int D.16783;
  int D.16786;
  unsigned int D.16787;
  unsigned int D.16788;
  void * i.0;
  int i.1;
  unsigned int i.2;
  unsigned int D.16793;
  void * * D.16794;
  void * D.16795;
  const char * * D.16796;
  short unsigned int D.16799;
  unsigned int D.16800;
  unsigned int D.16801;
  unsigned int i.3;
  unsigned int D.16803;
  char * * D.16804;
  const char * * D.16805;
  const char * D.16806;
  char * D.16807;
  int D.16808;
  struct GHashTable * D.16809;
  struct GHashTable * D.16812;
  struct MonoMethod * D.16813;
  struct MonoMethodHeader * header;
  struct MonoMethodWrapper * mw;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct GList * l;
  int i;

  D.16733 = mb == 0B;
  D.16734 = (long int) D.16733;
  D.16735 = __builtin_expect (D.16734, 0);
  if (D.16735 != 0) goto <D.16736>; else goto <D.16737>;
  <D.16736>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 132, "mb != NULL");
  <D.16737>:
  D.16738 = mb->method;
  D.16739 = D.16738->klass;
  image = D.16739->image;
  D.16740 = mb->dynamic;
  if (D.16740 != 0) goto <D.16741>; else goto <D.16742>;
  <D.16741>:
  method = mb->method;
  mw = method;
  D.16743 = mb->name;
  method->name = D.16743;
  method->dynamic = 1;
  D.16744 = mb->locals;
  D.16745 = (unsigned int) D.16744;
  D.16746 = D.16745 + 5;
  D.16747 = D.16746 * 4;
  header = monoeg_malloc0 (D.16747);
  mw->header = header;
  D.16748 = mb->code;
  header->code = D.16748;
  i = 0;
  l = mb->locals_list;
  goto <D.16541>;
  <D.16540>:
  D.16749 = l->data;
  D.16750 = mono_metadata_type_dup (0B, D.16749);
  header->locals[i] = D.16750;
  l = l->next;
  i = i + 1;
  <D.16541>:
  if (l != 0B) goto <D.16540>; else goto <D.16542>;
  <D.16542>:
  goto <D.16751>;
  <D.16742>:
  method = mono_image_alloc0 (image, 32);
  D.16738 = mb->method;
  memcpy (method, D.16738, 32);
  mw = method;
  D.16752 = mb->no_dup_name;
  if (D.16752 != 0) goto <D.16753>; else goto <D.16754>;
  <D.16753>:
  D.16743 = mb->name;
  method->name = D.16743;
  goto <D.16755>;
  <D.16754>:
  D.16743 = mb->name;
  D.16756 = mono_image_strdup (image, D.16743);
  method->name = D.16756;
  <D.16755>:
  D.16744 = mb->locals;
  D.16745 = (unsigned int) D.16744;
  D.16746 = D.16745 + 5;
  D.16747 = D.16746 * 4;
  header = mono_image_alloc0 (image, D.16747);
  mw->header = header;
  D.16757 = mb->pos;
  D.16758 = mono_image_alloc (image, D.16757);
  header->code = D.16758;
  D.16759 = header->code;
  D.16748 = mb->code;
  D.16757 = mb->pos;
  memcpy (D.16759, D.16748, D.16757);
  i = 0;
  l = mb->locals_list;
  goto <D.16544>;
  <D.16543>:
  D.16749 = l->data;
  header->locals[i] = D.16749;
  l = l->next;
  i = i + 1;
  <D.16544>:
  if (l != 0B) goto <D.16543>; else goto <D.16545>;
  <D.16545>:
  <D.16751>:
  method->signature = signature;
  D.16760 = BIT_FIELD_REF <*signature, 32, 64>;
  D.16761 = D.16760 & 4194304;
  if (D.16761 == 0) goto <D.16762>; else goto <D.16763>;
  <D.16762>:
  D.16764 = method->flags;
  D.16765 = D.16764 | 16;
  method->flags = D.16765;
  <D.16763>:
  if (max_stack <= 7) goto <D.16766>; else goto <D.16767>;
  <D.16766>:
  max_stack = 8;
  <D.16767>:
  D.16768 = (short unsigned int) max_stack;
  D.16769 = (<unnamed-unsigned:15>) D.16768;
  header->max_stack = D.16769;
  D.16757 = mb->pos;
  header->code_size = D.16757;
  D.16744 = mb->locals;
  D.16770 = (short unsigned int) D.16744;
  header->num_locals = D.16770;
  header->init_locals = 1;
  D.16771 = mb->num_clauses;
  D.16772 = (short unsigned int) D.16771;
  D.16773 = (<unnamed-unsigned:15>) D.16772;
  header->num_clauses = D.16773;
  D.16774 = mb->clauses;
  header->clauses = D.16774;
  D.16775 = mb->skip_visibility;
  D.16776 = (unsigned char) D.16775;
  D.16777 = (<unnamed-unsigned:1>) D.16776;
  method->skip_visibility = D.16777;
  D.16778 = mw->method_data;
  D.16779 = monoeg_g_list_length (D.16778);
  i = (int) D.16779;
  if (i != 0) goto <D.16780>; else goto <D.16781>;
  <D.16780>:
  {
    struct GList * tmp;
    void * * data;

    D.16778 = mw->method_data;
    l = monoeg_g_list_reverse (D.16778);
    D.16782 = BIT_FIELD_REF <*method, 32, 160>;
    D.16783 = D.16782 & 512;
    if (D.16783 != 0) goto <D.16784>; else goto <D.16785>;
    <D.16784>:
    D.16786 = i + 1;
    D.16787 = (unsigned int) D.16786;
    D.16788 = D.16787 * 4;
    data = monoeg_malloc (D.16788);
    goto <D.16789>;
    <D.16785>:
    D.16786 = i + 1;
    D.16787 = (unsigned int) D.16786;
    D.16788 = D.16787 * 4;
    data = mono_image_alloc (image, D.16788);
    <D.16789>:
    i.0 = (void *) i;
    *data = i.0;
    i = 1;
    tmp = l;
    goto <D.16549>;
    <D.16548>:
    i.1 = i;
    i = i.1 + 1;
    i.2 = (unsigned int) i.1;
    D.16793 = i.2 * 4;
    D.16794 = data + D.16793;
    D.16795 = tmp->data;
    *D.16794 = D.16795;
    tmp = tmp->next;
    <D.16549>:
    if (tmp != 0B) goto <D.16548>; else goto <D.16550>;
    <D.16550>:
    monoeg_g_list_free (l);
    mw->method_data = data;
  }
  <D.16781>:
  D.16796 = mb->param_names;
  if (D.16796 != 0B) goto <D.16797>; else goto <D.16798>;
  <D.16797>:
  {
    char * * param_names;

    D.16799 = signature->param_count;
    D.16800 = (unsigned int) D.16799;
    D.16801 = D.16800 * 4;
    param_names = mono_image_alloc0 (image, D.16801);
    i = 0;
    goto <D.16553>;
    <D.16552>:
    i.3 = (unsigned int) i;
    D.16803 = i.3 * 4;
    D.16804 = param_names + D.16803;
    D.16796 = mb->param_names;
    i.3 = (unsigned int) i;
    D.16803 = i.3 * 4;
    D.16805 = D.16796 + D.16803;
    D.16806 = *D.16805;
    D.16807 = mono_image_strdup (image, D.16806);
    *D.16804 = D.16807;
    i = i + 1;
    <D.16553>:
    D.16799 = signature->param_count;
    D.16808 = (int) D.16799;
    if (D.16808 > i) goto <D.16552>; else goto <D.16554>;
    <D.16554>:
    mono_image_lock (image);
    D.16809 = image->wrapper_param_names;
    if (D.16809 == 0B) goto <D.16810>; else goto <D.16811>;
    <D.16810>:
    D.16812 = monoeg_g_hash_table_new (0B, 0B);
    image->wrapper_param_names = D.16812;
    <D.16811>:
    D.16809 = image->wrapper_param_names;
    monoeg_g_hash_table_insert_replace (D.16809, method, param_names, 0);
    mono_image_unlock (image);
  }
  <D.16798>:
  D.16813 = method;
  return D.16813;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.16815;
  unsigned int D.16816;

  D.16816 = __builtin_object_size (__dest, 0);
  D.16815 = __builtin___memcpy_chk (__dest, __src, __len, D.16816);
  return D.16815;
}


mono_mb_add_data (struct MonoMethodBuilder * mb, void * data)
{
  _Bool D.16818;
  long int D.16819;
  long int D.16820;
  void * D.16823;
  struct GList * D.16824;
  guint32 D.16825;
  struct MonoMethodWrapper * mw;

  D.16818 = mb == 0B;
  D.16819 = (long int) D.16818;
  D.16820 = __builtin_expect (D.16819, 0);
  if (D.16820 != 0) goto <D.16821>; else goto <D.16822>;
  <D.16821>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 254, "mb != NULL");
  <D.16822>:
  mw = mb->method;
  D.16823 = mw->method_data;
  D.16824 = monoeg_g_list_prepend (D.16823, data);
  mw->method_data = D.16824;
  D.16823 = mw->method_data;
  D.16825 = monoeg_g_list_length (D.16823);
  return D.16825;
}


mono_mb_add_local (struct MonoMethodBuilder * mb, struct MonoType * type)
{
  _Bool D.16827;
  long int D.16828;
  long int D.16829;
  _Bool D.16832;
  long int D.16833;
  long int D.16834;
  struct GList * D.16837;
  struct GList * D.16838;
  int D.16839;
  int D.16840;
  int D.16841;
  int res;

  D.16827 = mb == 0B;
  D.16828 = (long int) D.16827;
  D.16829 = __builtin_expect (D.16828, 0);
  if (D.16829 != 0) goto <D.16830>; else goto <D.16831>;
  <D.16830>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 271, "mb != NULL");
  <D.16831>:
  D.16832 = type == 0B;
  D.16833 = (long int) D.16832;
  D.16834 = __builtin_expect (D.16833, 0);
  if (D.16834 != 0) goto <D.16835>; else goto <D.16836>;
  <D.16835>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 272, "type != NULL");
  <D.16836>:
  res = mb->locals;
  D.16837 = mb->locals_list;
  D.16838 = monoeg_g_list_append (D.16837, type);
  mb->locals_list = D.16838;
  D.16839 = mb->locals;
  D.16840 = D.16839 + 1;
  mb->locals = D.16840;
  D.16841 = res;
  return D.16841;
}


mono_mb_patch_addr (struct MonoMethodBuilder * mb, int pos, int value)
{
  unsigned char * D.16843;
  sizetype pos.4;
  unsigned char * D.16845;
  unsigned char D.16846;
  sizetype D.16847;
  unsigned char * D.16848;
  int D.16849;
  unsigned char D.16850;
  sizetype D.16851;
  unsigned char * D.16852;
  int D.16853;
  unsigned char D.16854;
  sizetype D.16855;
  unsigned char * D.16856;
  unsigned int value.5;
  unsigned int D.16858;
  unsigned char D.16859;

  D.16843 = mb->code;
  pos.4 = (sizetype) pos;
  D.16845 = D.16843 + pos.4;
  D.16846 = (unsigned char) value;
  *D.16845 = D.16846;
  D.16843 = mb->code;
  pos.4 = (sizetype) pos;
  D.16847 = pos.4 + 1;
  D.16848 = D.16843 + D.16847;
  D.16849 = value >> 8;
  D.16850 = (unsigned char) D.16849;
  *D.16848 = D.16850;
  D.16843 = mb->code;
  pos.4 = (sizetype) pos;
  D.16851 = pos.4 + 2;
  D.16852 = D.16843 + D.16851;
  D.16853 = value >> 16;
  D.16854 = (unsigned char) D.16853;
  *D.16852 = D.16854;
  D.16843 = mb->code;
  pos.4 = (sizetype) pos;
  D.16855 = pos.4 + 3;
  D.16856 = D.16843 + D.16855;
  value.5 = (unsigned int) value;
  D.16858 = value.5 >> 24;
  D.16859 = (unsigned char) D.16858;
  *D.16856 = D.16859;
}


mono_mb_patch_addr_s (struct MonoMethodBuilder * mb, int pos, gint8 value)
{
  unsigned char * D.16860;
  sizetype pos.6;
  gint8 * D.16862;

  D.16860 = mb->code;
  pos.6 = (sizetype) pos;
  D.16862 = D.16860 + pos.6;
  *D.16862 = value;
}


mono_mb_emit_byte (struct MonoMethodBuilder * mb, guint8 op)
{
  unsigned int D.16863;
  unsigned int D.16864;
  unsigned int D.16867;
  unsigned int D.16868;
  unsigned char * D.16869;
  void * D.16870;
  unsigned int D.16871;
  unsigned int D.16872;
  unsigned char * D.16873;

  D.16863 = mb->pos;
  D.16864 = mb->code_size;
  if (D.16863 >= D.16864) goto <D.16865>; else goto <D.16866>;
  <D.16865>:
  D.16864 = mb->code_size;
  D.16864 = mb->code_size;
  D.16867 = D.16864 >> 1;
  D.16868 = D.16864 + D.16867;
  mb->code_size = D.16868;
  D.16869 = mb->code;
  D.16864 = mb->code_size;
  D.16870 = monoeg_realloc (D.16869, D.16864);
  mb->code = D.16870;
  <D.16866>:
  D.16869 = mb->code;
  D.16863 = mb->pos;
  D.16871 = D.16863;
  D.16872 = D.16871 + 1;
  mb->pos = D.16872;
  D.16873 = D.16869 + D.16871;
  *D.16873 = op;
}


mono_mb_emit_ldflda (struct MonoMethodBuilder * mb, gint32 offset)
{
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 1);
  if (offset != 0) goto <D.16874>; else goto <D.16875>;
  <D.16874>:
  mono_mb_emit_icon (mb, offset);
  mono_mb_emit_byte (mb, 88);
  <D.16875>:
}


mono_mb_emit_i4 (struct MonoMethodBuilder * mb, gint32 data)
{
  unsigned int D.16876;
  unsigned int D.16877;
  unsigned int D.16878;
  unsigned int D.16881;
  unsigned int D.16882;
  unsigned char * D.16883;
  void * D.16884;
  int D.16885;

  D.16876 = mb->pos;
  D.16877 = D.16876 + 4;
  D.16878 = mb->code_size;
  if (D.16877 >= D.16878) goto <D.16879>; else goto <D.16880>;
  <D.16879>:
  D.16878 = mb->code_size;
  D.16878 = mb->code_size;
  D.16881 = D.16878 >> 1;
  D.16882 = D.16878 + D.16881;
  mb->code_size = D.16882;
  D.16883 = mb->code;
  D.16878 = mb->code_size;
  D.16884 = monoeg_realloc (D.16883, D.16878);
  mb->code = D.16884;
  <D.16880>:
  D.16876 = mb->pos;
  D.16885 = (int) D.16876;
  mono_mb_patch_addr (mb, D.16885, data);
  D.16876 = mb->pos;
  D.16877 = D.16876 + 4;
  mb->pos = D.16877;
}


mono_mb_emit_i2 (struct MonoMethodBuilder * mb, gint16 data)
{
  unsigned int D.16886;
  unsigned int D.16887;
  unsigned int D.16888;
  unsigned int D.16891;
  unsigned int D.16892;
  unsigned char * D.16893;
  void * D.16894;
  unsigned char * D.16895;
  unsigned char D.16896;
  sizetype D.16897;
  unsigned char * D.16898;
  short int D.16899;
  unsigned char D.16900;

  D.16886 = mb->pos;
  D.16887 = D.16886 + 2;
  D.16888 = mb->code_size;
  if (D.16887 >= D.16888) goto <D.16889>; else goto <D.16890>;
  <D.16889>:
  D.16888 = mb->code_size;
  D.16888 = mb->code_size;
  D.16891 = D.16888 >> 1;
  D.16892 = D.16888 + D.16891;
  mb->code_size = D.16892;
  D.16893 = mb->code;
  D.16888 = mb->code_size;
  D.16894 = monoeg_realloc (D.16893, D.16888);
  mb->code = D.16894;
  <D.16890>:
  D.16893 = mb->code;
  D.16886 = mb->pos;
  D.16895 = D.16893 + D.16886;
  D.16896 = (unsigned char) data;
  *D.16895 = D.16896;
  D.16893 = mb->code;
  D.16886 = mb->pos;
  D.16897 = D.16886 + 1;
  D.16898 = D.16893 + D.16897;
  D.16899 = data >> 8;
  D.16900 = (unsigned char) D.16899;
  *D.16898 = D.16900;
  D.16886 = mb->pos;
  D.16887 = D.16886 + 2;
  mb->pos = D.16887;
}


mono_mb_emit_op (struct MonoMethodBuilder * mb, guint8 op, void * data)
{
  int D.16901;
  unsigned int D.16902;
  int D.16903;

  D.16901 = (int) op;
  mono_mb_emit_byte (mb, D.16901);
  D.16902 = mono_mb_add_data (mb, data);
  D.16903 = (int) D.16902;
  mono_mb_emit_i4 (mb, D.16903);
}


mono_mb_emit_ldstr (struct MonoMethodBuilder * mb, char * str)
{
  mono_mb_emit_op (mb, 114, str);
}


mono_mb_emit_ldarg (struct MonoMethodBuilder * mb, guint argnum)
{
  unsigned char D.16906;
  unsigned char D.16907;
  int D.16908;
  int D.16912;
  short int D.16914;
  int D.16915;

  if (argnum <= 3) goto <D.16904>; else goto <D.16905>;
  <D.16904>:
  D.16906 = (unsigned char) argnum;
  D.16907 = D.16906 + 2;
  D.16908 = (int) D.16907;
  mono_mb_emit_byte (mb, D.16908);
  goto <D.16909>;
  <D.16905>:
  if (argnum <= 255) goto <D.16910>; else goto <D.16911>;
  <D.16910>:
  mono_mb_emit_byte (mb, 14);
  D.16906 = (unsigned char) argnum;
  D.16912 = (int) D.16906;
  mono_mb_emit_byte (mb, D.16912);
  goto <D.16913>;
  <D.16911>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 9);
  D.16914 = (short int) argnum;
  D.16915 = (int) D.16914;
  mono_mb_emit_i2 (mb, D.16915);
  <D.16913>:
  <D.16909>:
}


mono_mb_emit_ldarg_addr (struct MonoMethodBuilder * mb, guint argnum)
{
  unsigned char D.16918;
  int D.16919;
  short int D.16921;
  int D.16922;

  if (argnum <= 255) goto <D.16916>; else goto <D.16917>;
  <D.16916>:
  mono_mb_emit_byte (mb, 15);
  D.16918 = (unsigned char) argnum;
  D.16919 = (int) D.16918;
  mono_mb_emit_byte (mb, D.16919);
  goto <D.16920>;
  <D.16917>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 10);
  D.16921 = (short int) argnum;
  D.16922 = (int) D.16921;
  mono_mb_emit_i2 (mb, D.16922);
  <D.16920>:
}


mono_mb_emit_ldloc_addr (struct MonoMethodBuilder * mb, guint locnum)
{
  unsigned char D.16925;
  int D.16926;
  short int D.16928;
  int D.16929;

  if (locnum <= 255) goto <D.16923>; else goto <D.16924>;
  <D.16923>:
  mono_mb_emit_byte (mb, 18);
  D.16925 = (unsigned char) locnum;
  D.16926 = (int) D.16925;
  mono_mb_emit_byte (mb, D.16926);
  goto <D.16927>;
  <D.16924>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 13);
  D.16928 = (short int) locnum;
  D.16929 = (int) D.16928;
  mono_mb_emit_i2 (mb, D.16929);
  <D.16927>:
}


mono_mb_emit_ldloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.16932;
  unsigned char D.16933;
  int D.16934;
  int D.16938;
  short int D.16940;
  int D.16941;

  if (num <= 3) goto <D.16930>; else goto <D.16931>;
  <D.16930>:
  D.16932 = (unsigned char) num;
  D.16933 = D.16932 + 6;
  D.16934 = (int) D.16933;
  mono_mb_emit_byte (mb, D.16934);
  goto <D.16935>;
  <D.16931>:
  if (num <= 255) goto <D.16936>; else goto <D.16937>;
  <D.16936>:
  mono_mb_emit_byte (mb, 17);
  D.16932 = (unsigned char) num;
  D.16938 = (int) D.16932;
  mono_mb_emit_byte (mb, D.16938);
  goto <D.16939>;
  <D.16937>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 12);
  D.16940 = (short int) num;
  D.16941 = (int) D.16940;
  mono_mb_emit_i2 (mb, D.16941);
  <D.16939>:
  <D.16935>:
}


mono_mb_emit_stloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.16944;
  unsigned char D.16945;
  int D.16946;
  int D.16950;
  short int D.16952;
  int D.16953;

  if (num <= 3) goto <D.16942>; else goto <D.16943>;
  <D.16942>:
  D.16944 = (unsigned char) num;
  D.16945 = D.16944 + 10;
  D.16946 = (int) D.16945;
  mono_mb_emit_byte (mb, D.16946);
  goto <D.16947>;
  <D.16943>:
  if (num <= 255) goto <D.16948>; else goto <D.16949>;
  <D.16948>:
  mono_mb_emit_byte (mb, 19);
  D.16944 = (unsigned char) num;
  D.16950 = (int) D.16944;
  mono_mb_emit_byte (mb, D.16950);
  goto <D.16951>;
  <D.16949>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 14);
  D.16952 = (short int) num;
  D.16953 = (int) D.16952;
  mono_mb_emit_i2 (mb, D.16953);
  <D.16951>:
  <D.16947>:
}


mono_mb_emit_icon (struct MonoMethodBuilder * mb, gint32 value)
{
  unsigned int value.7;
  unsigned int D.16955;
  unsigned char D.16958;
  unsigned char D.16959;
  int D.16960;
  unsigned int D.16962;
  int D.16965;

  value.7 = (unsigned int) value;
  D.16955 = value.7 + 1;
  if (D.16955 <= 8) goto <D.16956>; else goto <D.16957>;
  <D.16956>:
  D.16958 = (unsigned char) value;
  D.16959 = D.16958 + 22;
  D.16960 = (int) D.16959;
  mono_mb_emit_byte (mb, D.16960);
  goto <D.16961>;
  <D.16957>:
  value.7 = (unsigned int) value;
  D.16962 = value.7 + 128;
  if (D.16962 <= 255) goto <D.16963>; else goto <D.16964>;
  <D.16963>:
  mono_mb_emit_byte (mb, 31);
  D.16958 = (unsigned char) value;
  D.16965 = (int) D.16958;
  mono_mb_emit_byte (mb, D.16965);
  goto <D.16966>;
  <D.16964>:
  mono_mb_emit_byte (mb, 32);
  mono_mb_emit_i4 (mb, value);
  <D.16966>:
  <D.16961>:
}


mono_mb_get_label (struct MonoMethodBuilder * mb)
{
  int D.16967;
  unsigned int D.16968;

  D.16968 = mb->pos;
  D.16967 = (int) D.16968;
  return D.16967;
}


mono_mb_get_pos (struct MonoMethodBuilder * mb)
{
  int D.16970;
  unsigned int D.16971;

  D.16971 = mb->pos;
  D.16970 = (int) D.16971;
  return D.16970;
}


mono_mb_emit_branch (struct MonoMethodBuilder * mb, guint8 op)
{
  int D.16973;
  guint32 D.16974;
  guint32 res;

  D.16973 = (int) op;
  mono_mb_emit_byte (mb, D.16973);
  res = mb->pos;
  mono_mb_emit_i4 (mb, 0);
  D.16974 = res;
  return D.16974;
}


mono_mb_emit_short_branch (struct MonoMethodBuilder * mb, guint8 op)
{
  int D.16976;
  guint32 D.16977;
  guint32 res;

  D.16976 = (int) op;
  mono_mb_emit_byte (mb, D.16976);
  res = mb->pos;
  mono_mb_emit_byte (mb, 0);
  D.16977 = res;
  return D.16977;
}


mono_mb_emit_branch_label (struct MonoMethodBuilder * mb, guint8 op, guint32 label)
{
  int D.16979;
  unsigned int D.16980;
  unsigned int D.16981;
  unsigned int D.16982;
  int D.16983;

  D.16979 = (int) op;
  mono_mb_emit_byte (mb, D.16979);
  D.16980 = mb->pos;
  D.16981 = label - D.16980;
  D.16982 = D.16981 + 4294967292;
  D.16983 = (int) D.16982;
  mono_mb_emit_i4 (mb, D.16983);
}


mono_mb_patch_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.8;
  unsigned int D.16985;
  unsigned int D.16986;
  unsigned int D.16987;
  int D.16988;

  pos.8 = (int) pos;
  D.16985 = mb->pos;
  D.16986 = D.16985 - pos;
  D.16987 = D.16986 + 4294967292;
  D.16988 = (int) D.16987;
  mono_mb_patch_addr (mb, pos.8, D.16988);
}


mono_mb_patch_short_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.9;
  unsigned int D.16990;
  unsigned char D.16991;
  unsigned char D.16992;
  unsigned char D.16993;
  unsigned char D.16994;
  signed char D.16995;
  int D.16996;

  pos.9 = (int) pos;
  D.16990 = mb->pos;
  D.16991 = (unsigned char) D.16990;
  D.16992 = (unsigned char) pos;
  D.16993 = D.16991 - D.16992;
  D.16994 = D.16993 + 255;
  D.16995 = (signed char) D.16994;
  D.16996 = (int) D.16995;
  mono_mb_patch_addr_s (mb, pos.9, D.16996);
}


mono_mb_emit_ptr (struct MonoMethodBuilder * mb, void * ptr)
{
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 2, ptr);
}


mono_mb_emit_calli (struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig)
{
  mono_mb_emit_op (mb, 41, sig);
}


mono_mb_emit_managed_call (struct MonoMethodBuilder * mb, struct MonoMethod * method, struct MonoMethodSignature * opt_sig)
{
  mono_mb_emit_op (mb, 40, method);
}


mono_mb_emit_native_call (struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig, void * func)
{
  mono_mb_emit_ptr (mb, func);
  mono_mb_emit_calli (mb, sig);
}


mono_mb_emit_icall (struct MonoMethodBuilder * mb, void * func)
{
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 0, func);
}


mono_mb_emit_exception_full (struct MonoMethodBuilder * mb, const char * exc_nspace, const char * exc_name, const char * msg)
{
  struct MonoImage * D.16997;
  _Bool D.16998;
  long int D.16999;
  long int D.17000;
  struct MonoMethod * ctor;
  struct MonoClass * mme;

  ctor = 0B;
  D.16997 = mono_defaults.corlib;
  mme = mono_class_from_name (D.16997, exc_nspace, exc_name);
  mono_class_init (mme);
  ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
  D.16998 = ctor == 0B;
  D.16999 = (long int) D.16998;
  D.17000 = __builtin_expect (D.16999, 0);
  if (D.17000 != 0) goto <D.17001>; else goto <D.17002>;
  <D.17001>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 535, "ctor");
  <D.17002>:
  mono_mb_emit_op (mb, 115, ctor);
  if (msg != 0B) goto <D.17003>; else goto <D.17004>;
  <D.17003>:
  mono_mb_emit_byte (mb, 37);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_ldstr (mb, msg);
  mono_mb_emit_byte (mb, 81);
  <D.17004>:
  mono_mb_emit_byte (mb, 122);
}


mono_mb_emit_exception (struct MonoMethodBuilder * mb, const char * exc_name, const char * msg)
{
  mono_mb_emit_exception_full (mb, "System", exc_name, msg);
}


mono_mb_emit_add_to_local (struct MonoMethodBuilder * mb, guint16 local, gint32 incr)
{
  unsigned int D.17005;

  D.17005 = (unsigned int) local;
  mono_mb_emit_ldloc (mb, D.17005);
  mono_mb_emit_icon (mb, incr);
  mono_mb_emit_byte (mb, 88);
  D.17005 = (unsigned int) local;
  mono_mb_emit_stloc (mb, D.17005);
}


mono_mb_set_clauses (struct MonoMethodBuilder * mb, int num_clauses, struct MonoExceptionClause * clauses)
{
  mb->num_clauses = num_clauses;
  mb->clauses = clauses;
}


mono_mb_set_param_names (struct MonoMethodBuilder * mb, const char * * param_names)
{
  mb->param_names = param_names;
}