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

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


mono_mb_new_base (struct MonoClass * klass, MonoWrapperType type)
{
  _Bool D.16739;
  long int D.16740;
  long int D.16741;
  unsigned char D.16744;
  <unnamed-unsigned:5> D.16745;
  unsigned int D.16746;
  void * D.16747;
  struct MonoMethodBuilder * D.16748;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * m;

  D.16739 = klass == 0B;
  D.16740 = (long int) D.16739;
  D.16741 = __builtin_expect (D.16740, 0);
  if (D.16741 != 0) goto <D.16742>; else goto <D.16743>;
  <D.16742>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 57, "klass != NULL");
  <D.16743>:
  mb = monoeg_malloc0 (52);
  m = monoeg_malloc0 (32);
  mb->method = m;
  m->klass = klass;
  m->inline_info = 1;
  D.16744 = (unsigned char) type;
  D.16745 = (<unnamed-unsigned:5>) D.16744;
  m->wrapper_type = D.16745;
  mb->code_size = 40;
  D.16746 = mb->code_size;
  D.16747 = monoeg_malloc (D.16746);
  mb->code = D.16747;
  mono_mb_add_data (mb, 0B);
  D.16748 = mb;
  return D.16748;
}


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

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


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

  if (str != 0B) goto <D.16753>; else goto <D.16754>;
  <D.16753>:
  D.16755 = __strdup (str);
  return D.16755;
  <D.16754>:
  D.16755 = 0B;
  return D.16755;
}


mono_mb_free (struct MonoMethodBuilder * mb)
{
  struct GList * D.16757;
  int D.16758;
  struct MonoMethod * D.16761;
  int D.16762;
  char * D.16765;
  unsigned char * D.16766;

  D.16757 = mb->locals_list;
  monoeg_g_list_free (D.16757);
  D.16758 = mb->dynamic;
  if (D.16758 == 0) goto <D.16759>; else goto <D.16760>;
  <D.16759>:
  D.16761 = mb->method;
  monoeg_g_free (D.16761);
  D.16762 = mb->no_dup_name;
  if (D.16762 == 0) goto <D.16763>; else goto <D.16764>;
  <D.16763>:
  D.16765 = mb->name;
  monoeg_g_free (D.16765);
  <D.16764>:
  D.16766 = mb->code;
  monoeg_g_free (D.16766);
  <D.16760>:
  monoeg_g_free (mb);
}


mono_mb_create_method (struct MonoMethodBuilder * mb, struct MonoMethodSignature * signature, int max_stack)
{
  _Bool D.16767;
  long int D.16768;
  long int D.16769;
  struct MonoMethod * D.16772;
  struct MonoClass * D.16773;
  int D.16774;
  char * D.16777;
  int D.16778;
  unsigned int D.16779;
  unsigned int D.16780;
  unsigned int D.16781;
  unsigned char * D.16782;
  void * D.16783;
  struct MonoType * D.16784;
  int D.16786;
  char * D.16790;
  unsigned int D.16791;
  void * D.16792;
  const unsigned char * D.16793;
  unsigned char D.16794;
  unsigned char D.16795;
  short unsigned int D.16798;
  short unsigned int D.16799;
  short unsigned int D.16802;
  <unnamed-unsigned:15> D.16803;
  short unsigned int D.16804;
  int D.16805;
  short unsigned int D.16806;
  <unnamed-unsigned:15> D.16807;
  struct MonoExceptionClause * D.16808;
  int D.16809;
  unsigned char D.16810;
  <unnamed-unsigned:1> D.16811;
  void * D.16812;
  unsigned int D.16813;
  unsigned char D.16816;
  unsigned char D.16817;
  int D.16820;
  unsigned int D.16821;
  unsigned int D.16822;
  void * i.0;
  int i.1;
  unsigned int i.2;
  unsigned int D.16827;
  void * * D.16828;
  void * D.16829;
  const char * * D.16830;
  short unsigned int D.16833;
  unsigned int D.16834;
  unsigned int D.16835;
  unsigned int i.3;
  unsigned int D.16837;
  char * * D.16838;
  const char * * D.16839;
  const char * D.16840;
  char * D.16841;
  int D.16842;
  struct GHashTable * D.16843;
  struct GHashTable * D.16846;
  struct MonoMethod * D.16847;
  struct MonoMethodHeader * header;
  struct MonoMethodWrapper * mw;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct GList * l;
  int i;

  D.16767 = mb == 0B;
  D.16768 = (long int) D.16767;
  D.16769 = __builtin_expect (D.16768, 0);
  if (D.16769 != 0) goto <D.16770>; else goto <D.16771>;
  <D.16770>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 132, "mb != NULL");
  <D.16771>:
  D.16772 = mb->method;
  D.16773 = D.16772->klass;
  image = D.16773->image;
  D.16774 = mb->dynamic;
  if (D.16774 != 0) goto <D.16775>; else goto <D.16776>;
  <D.16775>:
  method = mb->method;
  mw = method;
  D.16777 = mb->name;
  method->name = D.16777;
  method->dynamic = 1;
  D.16778 = mb->locals;
  D.16779 = (unsigned int) D.16778;
  D.16780 = D.16779 + 5;
  D.16781 = D.16780 * 4;
  header = monoeg_malloc0 (D.16781);
  mw->header = header;
  D.16782 = mb->code;
  header->code = D.16782;
  i = 0;
  l = mb->locals_list;
  goto <D.16575>;
  <D.16574>:
  D.16783 = l->data;
  D.16784 = mono_metadata_type_dup (0B, D.16783);
  header->locals[i] = D.16784;
  l = l->next;
  i = i + 1;
  <D.16575>:
  if (l != 0B) goto <D.16574>; else goto <D.16576>;
  <D.16576>:
  goto <D.16785>;
  <D.16776>:
  method = mono_image_alloc0 (image, 32);
  D.16772 = mb->method;
  memcpy (method, D.16772, 32);
  mw = method;
  D.16786 = mb->no_dup_name;
  if (D.16786 != 0) goto <D.16787>; else goto <D.16788>;
  <D.16787>:
  D.16777 = mb->name;
  method->name = D.16777;
  goto <D.16789>;
  <D.16788>:
  D.16777 = mb->name;
  D.16790 = mono_image_strdup (image, D.16777);
  method->name = D.16790;
  <D.16789>:
  D.16778 = mb->locals;
  D.16779 = (unsigned int) D.16778;
  D.16780 = D.16779 + 5;
  D.16781 = D.16780 * 4;
  header = mono_image_alloc0 (image, D.16781);
  mw->header = header;
  D.16791 = mb->pos;
  D.16792 = mono_image_alloc (image, D.16791);
  header->code = D.16792;
  D.16791 = mb->pos;
  D.16782 = mb->code;
  D.16793 = header->code;
  memcpy (D.16793, D.16782, D.16791);
  i = 0;
  l = mb->locals_list;
  goto <D.16578>;
  <D.16577>:
  D.16783 = l->data;
  header->locals[i] = D.16783;
  l = l->next;
  i = i + 1;
  <D.16578>:
  if (l != 0B) goto <D.16577>; else goto <D.16579>;
  <D.16579>:
  <D.16785>:
  method->signature = signature;
  D.16794 = BIT_FIELD_REF <*signature, 8, 80>;
  D.16795 = D.16794 & 64;
  if (D.16795 == 0) goto <D.16796>; else goto <D.16797>;
  <D.16796>:
  D.16798 = method->flags;
  D.16799 = D.16798 | 16;
  method->flags = D.16799;
  <D.16797>:
  if (max_stack <= 7) goto <D.16800>; else goto <D.16801>;
  <D.16800>:
  max_stack = 8;
  <D.16801>:
  D.16802 = (short unsigned int) max_stack;
  D.16803 = (<unnamed-unsigned:15>) D.16802;
  header->max_stack = D.16803;
  D.16791 = mb->pos;
  header->code_size = D.16791;
  D.16778 = mb->locals;
  D.16804 = (short unsigned int) D.16778;
  header->num_locals = D.16804;
  header->init_locals = 1;
  D.16805 = mb->num_clauses;
  D.16806 = (short unsigned int) D.16805;
  D.16807 = (<unnamed-unsigned:15>) D.16806;
  header->num_clauses = D.16807;
  D.16808 = mb->clauses;
  header->clauses = D.16808;
  D.16809 = mb->skip_visibility;
  D.16810 = (unsigned char) D.16809;
  D.16811 = (<unnamed-unsigned:1>) D.16810;
  method->skip_visibility = D.16811;
  D.16812 = mw->method_data;
  D.16813 = monoeg_g_list_length (D.16812);
  i = (int) D.16813;
  if (i != 0) goto <D.16814>; else goto <D.16815>;
  <D.16814>:
  {
    struct GList * tmp;
    void * * data;

    D.16812 = mw->method_data;
    l = monoeg_g_list_reverse (D.16812);
    D.16816 = BIT_FIELD_REF <*method, 8, 168>;
    D.16817 = D.16816 & 2;
    if (D.16817 != 0) goto <D.16818>; else goto <D.16819>;
    <D.16818>:
    D.16820 = i + 1;
    D.16821 = (unsigned int) D.16820;
    D.16822 = D.16821 * 4;
    data = monoeg_malloc (D.16822);
    goto <D.16823>;
    <D.16819>:
    D.16820 = i + 1;
    D.16821 = (unsigned int) D.16820;
    D.16822 = D.16821 * 4;
    data = mono_image_alloc (image, D.16822);
    <D.16823>:
    i.0 = (void *) i;
    *data = i.0;
    i = 1;
    tmp = l;
    goto <D.16583>;
    <D.16582>:
    i.1 = i;
    i = i.1 + 1;
    i.2 = (unsigned int) i.1;
    D.16827 = i.2 * 4;
    D.16828 = data + D.16827;
    D.16829 = tmp->data;
    *D.16828 = D.16829;
    tmp = tmp->next;
    <D.16583>:
    if (tmp != 0B) goto <D.16582>; else goto <D.16584>;
    <D.16584>:
    monoeg_g_list_free (l);
    mw->method_data = data;
  }
  <D.16815>:
  D.16830 = mb->param_names;
  if (D.16830 != 0B) goto <D.16831>; else goto <D.16832>;
  <D.16831>:
  {
    char * * param_names;

    D.16833 = signature->param_count;
    D.16834 = (unsigned int) D.16833;
    D.16835 = D.16834 * 4;
    param_names = mono_image_alloc0 (image, D.16835);
    i = 0;
    goto <D.16587>;
    <D.16586>:
    i.3 = (unsigned int) i;
    D.16837 = i.3 * 4;
    D.16838 = param_names + D.16837;
    D.16830 = mb->param_names;
    i.3 = (unsigned int) i;
    D.16837 = i.3 * 4;
    D.16839 = D.16830 + D.16837;
    D.16840 = *D.16839;
    D.16841 = mono_image_strdup (image, D.16840);
    *D.16838 = D.16841;
    i = i + 1;
    <D.16587>:
    D.16833 = signature->param_count;
    D.16842 = (int) D.16833;
    if (D.16842 > i) goto <D.16586>; else goto <D.16588>;
    <D.16588>:
    mono_image_lock (image);
    D.16843 = image->wrapper_param_names;
    if (D.16843 == 0B) goto <D.16844>; else goto <D.16845>;
    <D.16844>:
    D.16846 = monoeg_g_hash_table_new (0B, 0B);
    image->wrapper_param_names = D.16846;
    <D.16845>:
    D.16843 = image->wrapper_param_names;
    monoeg_g_hash_table_insert_replace (D.16843, method, param_names, 0);
    mono_image_unlock (image);
  }
  <D.16832>:
  D.16847 = method;
  return D.16847;
}


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

  D.16850 = __builtin_object_size (__dest, 0);
  D.16849 = __builtin___memcpy_chk (__dest, __src, __len, D.16850);
  return D.16849;
}


mono_mb_add_data (struct MonoMethodBuilder * mb, void * data)
{
  _Bool D.16852;
  long int D.16853;
  long int D.16854;
  void * D.16857;
  struct GList * D.16858;
  guint32 D.16859;
  struct MonoMethodWrapper * mw;

  D.16852 = mb == 0B;
  D.16853 = (long int) D.16852;
  D.16854 = __builtin_expect (D.16853, 0);
  if (D.16854 != 0) goto <D.16855>; else goto <D.16856>;
  <D.16855>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 254, "mb != NULL");
  <D.16856>:
  mw = mb->method;
  D.16857 = mw->method_data;
  D.16858 = monoeg_g_list_prepend (D.16857, data);
  mw->method_data = D.16858;
  D.16857 = mw->method_data;
  D.16859 = monoeg_g_list_length (D.16857);
  return D.16859;
}


mono_mb_add_local (struct MonoMethodBuilder * mb, struct MonoType * type)
{
  _Bool D.16861;
  long int D.16862;
  long int D.16863;
  _Bool D.16866;
  long int D.16867;
  long int D.16868;
  struct GList * D.16871;
  struct GList * D.16872;
  int D.16873;
  int D.16874;
  int D.16875;
  int res;

  D.16861 = mb == 0B;
  D.16862 = (long int) D.16861;
  D.16863 = __builtin_expect (D.16862, 0);
  if (D.16863 != 0) goto <D.16864>; else goto <D.16865>;
  <D.16864>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 271, "mb != NULL");
  <D.16865>:
  D.16866 = type == 0B;
  D.16867 = (long int) D.16866;
  D.16868 = __builtin_expect (D.16867, 0);
  if (D.16868 != 0) goto <D.16869>; else goto <D.16870>;
  <D.16869>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 272, "type != NULL");
  <D.16870>:
  res = mb->locals;
  D.16871 = mb->locals_list;
  D.16872 = monoeg_g_list_append (D.16871, type);
  mb->locals_list = D.16872;
  D.16873 = mb->locals;
  D.16874 = D.16873 + 1;
  mb->locals = D.16874;
  D.16875 = res;
  return D.16875;
}


mono_mb_patch_addr (struct MonoMethodBuilder * mb, int pos, int value)
{
  unsigned char * D.16877;
  sizetype pos.4;
  unsigned char * D.16879;
  unsigned char D.16880;
  sizetype D.16881;
  unsigned char * D.16882;
  int D.16883;
  unsigned char D.16884;
  sizetype D.16885;
  unsigned char * D.16886;
  int D.16887;
  unsigned char D.16888;
  sizetype D.16889;
  unsigned char * D.16890;
  unsigned int value.5;
  unsigned int D.16892;
  unsigned char D.16893;

  D.16877 = mb->code;
  pos.4 = (sizetype) pos;
  D.16879 = D.16877 + pos.4;
  D.16880 = (unsigned char) value;
  *D.16879 = D.16880;
  D.16877 = mb->code;
  pos.4 = (sizetype) pos;
  D.16881 = pos.4 + 1;
  D.16882 = D.16877 + D.16881;
  D.16883 = value >> 8;
  D.16884 = (unsigned char) D.16883;
  *D.16882 = D.16884;
  D.16877 = mb->code;
  pos.4 = (sizetype) pos;
  D.16885 = pos.4 + 2;
  D.16886 = D.16877 + D.16885;
  D.16887 = value >> 16;
  D.16888 = (unsigned char) D.16887;
  *D.16886 = D.16888;
  D.16877 = mb->code;
  pos.4 = (sizetype) pos;
  D.16889 = pos.4 + 3;
  D.16890 = D.16877 + D.16889;
  value.5 = (unsigned int) value;
  D.16892 = value.5 >> 24;
  D.16893 = (unsigned char) D.16892;
  *D.16890 = D.16893;
}


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

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


mono_mb_emit_byte (struct MonoMethodBuilder * mb, guint8 op)
{
  unsigned int D.16897;
  unsigned int D.16898;
  unsigned int D.16901;
  unsigned int D.16902;
  unsigned char * D.16903;
  void * D.16904;
  unsigned int D.16905;
  unsigned int D.16906;
  unsigned char * D.16907;

  D.16897 = mb->pos;
  D.16898 = mb->code_size;
  if (D.16897 >= D.16898) goto <D.16899>; else goto <D.16900>;
  <D.16899>:
  D.16898 = mb->code_size;
  D.16898 = mb->code_size;
  D.16901 = D.16898 >> 1;
  D.16902 = D.16898 + D.16901;
  mb->code_size = D.16902;
  D.16898 = mb->code_size;
  D.16903 = mb->code;
  D.16904 = monoeg_realloc (D.16903, D.16898);
  mb->code = D.16904;
  <D.16900>:
  D.16903 = mb->code;
  D.16897 = mb->pos;
  D.16905 = D.16897;
  D.16906 = D.16905 + 1;
  mb->pos = D.16906;
  D.16907 = D.16903 + D.16905;
  *D.16907 = 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.16908>; else goto <D.16909>;
  <D.16908>:
  mono_mb_emit_icon (mb, offset);
  mono_mb_emit_byte (mb, 88);
  <D.16909>:
}


mono_mb_emit_i4 (struct MonoMethodBuilder * mb, gint32 data)
{
  unsigned int D.16910;
  unsigned int D.16911;
  unsigned int D.16912;
  unsigned int D.16915;
  unsigned int D.16916;
  unsigned char * D.16917;
  void * D.16918;
  int D.16919;

  D.16910 = mb->pos;
  D.16911 = D.16910 + 4;
  D.16912 = mb->code_size;
  if (D.16911 >= D.16912) goto <D.16913>; else goto <D.16914>;
  <D.16913>:
  D.16912 = mb->code_size;
  D.16912 = mb->code_size;
  D.16915 = D.16912 >> 1;
  D.16916 = D.16912 + D.16915;
  mb->code_size = D.16916;
  D.16912 = mb->code_size;
  D.16917 = mb->code;
  D.16918 = monoeg_realloc (D.16917, D.16912);
  mb->code = D.16918;
  <D.16914>:
  D.16910 = mb->pos;
  D.16919 = (int) D.16910;
  mono_mb_patch_addr (mb, D.16919, data);
  D.16910 = mb->pos;
  D.16911 = D.16910 + 4;
  mb->pos = D.16911;
}


mono_mb_emit_i2 (struct MonoMethodBuilder * mb, gint16 data)
{
  unsigned int D.16920;
  unsigned int D.16921;
  unsigned int D.16922;
  unsigned int D.16925;
  unsigned int D.16926;
  unsigned char * D.16927;
  void * D.16928;
  unsigned char * D.16929;
  unsigned char D.16930;
  sizetype D.16931;
  unsigned char * D.16932;
  short int D.16933;
  unsigned char D.16934;

  D.16920 = mb->pos;
  D.16921 = D.16920 + 2;
  D.16922 = mb->code_size;
  if (D.16921 >= D.16922) goto <D.16923>; else goto <D.16924>;
  <D.16923>:
  D.16922 = mb->code_size;
  D.16922 = mb->code_size;
  D.16925 = D.16922 >> 1;
  D.16926 = D.16922 + D.16925;
  mb->code_size = D.16926;
  D.16922 = mb->code_size;
  D.16927 = mb->code;
  D.16928 = monoeg_realloc (D.16927, D.16922);
  mb->code = D.16928;
  <D.16924>:
  D.16927 = mb->code;
  D.16920 = mb->pos;
  D.16929 = D.16927 + D.16920;
  D.16930 = (unsigned char) data;
  *D.16929 = D.16930;
  D.16927 = mb->code;
  D.16920 = mb->pos;
  D.16931 = D.16920 + 1;
  D.16932 = D.16927 + D.16931;
  D.16933 = data >> 8;
  D.16934 = (unsigned char) D.16933;
  *D.16932 = D.16934;
  D.16920 = mb->pos;
  D.16921 = D.16920 + 2;
  mb->pos = D.16921;
}


mono_mb_emit_op (struct MonoMethodBuilder * mb, guint8 op, void * data)
{
  int D.16935;
  unsigned int D.16936;
  int D.16937;

  D.16935 = (int) op;
  mono_mb_emit_byte (mb, D.16935);
  D.16936 = mono_mb_add_data (mb, data);
  D.16937 = (int) D.16936;
  mono_mb_emit_i4 (mb, D.16937);
}


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.16940;
  unsigned char D.16941;
  int D.16942;
  int D.16946;
  short int D.16948;
  int D.16949;

  if (argnum <= 3) goto <D.16938>; else goto <D.16939>;
  <D.16938>:
  D.16940 = (unsigned char) argnum;
  D.16941 = D.16940 + 2;
  D.16942 = (int) D.16941;
  mono_mb_emit_byte (mb, D.16942);
  goto <D.16943>;
  <D.16939>:
  if (argnum <= 255) goto <D.16944>; else goto <D.16945>;
  <D.16944>:
  mono_mb_emit_byte (mb, 14);
  D.16940 = (unsigned char) argnum;
  D.16946 = (int) D.16940;
  mono_mb_emit_byte (mb, D.16946);
  goto <D.16947>;
  <D.16945>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 9);
  D.16948 = (short int) argnum;
  D.16949 = (int) D.16948;
  mono_mb_emit_i2 (mb, D.16949);
  <D.16947>:
  <D.16943>:
}


mono_mb_emit_ldarg_addr (struct MonoMethodBuilder * mb, guint argnum)
{
  unsigned char D.16952;
  int D.16953;
  short int D.16955;
  int D.16956;

  if (argnum <= 255) goto <D.16950>; else goto <D.16951>;
  <D.16950>:
  mono_mb_emit_byte (mb, 15);
  D.16952 = (unsigned char) argnum;
  D.16953 = (int) D.16952;
  mono_mb_emit_byte (mb, D.16953);
  goto <D.16954>;
  <D.16951>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 10);
  D.16955 = (short int) argnum;
  D.16956 = (int) D.16955;
  mono_mb_emit_i2 (mb, D.16956);
  <D.16954>:
}


mono_mb_emit_ldloc_addr (struct MonoMethodBuilder * mb, guint locnum)
{
  unsigned char D.16959;
  int D.16960;
  short int D.16962;
  int D.16963;

  if (locnum <= 255) goto <D.16957>; else goto <D.16958>;
  <D.16957>:
  mono_mb_emit_byte (mb, 18);
  D.16959 = (unsigned char) locnum;
  D.16960 = (int) D.16959;
  mono_mb_emit_byte (mb, D.16960);
  goto <D.16961>;
  <D.16958>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 13);
  D.16962 = (short int) locnum;
  D.16963 = (int) D.16962;
  mono_mb_emit_i2 (mb, D.16963);
  <D.16961>:
}


mono_mb_emit_ldloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.16966;
  unsigned char D.16967;
  int D.16968;
  int D.16972;
  short int D.16974;
  int D.16975;

  if (num <= 3) goto <D.16964>; else goto <D.16965>;
  <D.16964>:
  D.16966 = (unsigned char) num;
  D.16967 = D.16966 + 6;
  D.16968 = (int) D.16967;
  mono_mb_emit_byte (mb, D.16968);
  goto <D.16969>;
  <D.16965>:
  if (num <= 255) goto <D.16970>; else goto <D.16971>;
  <D.16970>:
  mono_mb_emit_byte (mb, 17);
  D.16966 = (unsigned char) num;
  D.16972 = (int) D.16966;
  mono_mb_emit_byte (mb, D.16972);
  goto <D.16973>;
  <D.16971>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 12);
  D.16974 = (short int) num;
  D.16975 = (int) D.16974;
  mono_mb_emit_i2 (mb, D.16975);
  <D.16973>:
  <D.16969>:
}


mono_mb_emit_stloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.16978;
  unsigned char D.16979;
  int D.16980;
  int D.16984;
  short int D.16986;
  int D.16987;

  if (num <= 3) goto <D.16976>; else goto <D.16977>;
  <D.16976>:
  D.16978 = (unsigned char) num;
  D.16979 = D.16978 + 10;
  D.16980 = (int) D.16979;
  mono_mb_emit_byte (mb, D.16980);
  goto <D.16981>;
  <D.16977>:
  if (num <= 255) goto <D.16982>; else goto <D.16983>;
  <D.16982>:
  mono_mb_emit_byte (mb, 19);
  D.16978 = (unsigned char) num;
  D.16984 = (int) D.16978;
  mono_mb_emit_byte (mb, D.16984);
  goto <D.16985>;
  <D.16983>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 14);
  D.16986 = (short int) num;
  D.16987 = (int) D.16986;
  mono_mb_emit_i2 (mb, D.16987);
  <D.16985>:
  <D.16981>:
}


mono_mb_emit_icon (struct MonoMethodBuilder * mb, gint32 value)
{
  unsigned int value.7;
  unsigned int D.16989;
  unsigned char D.16992;
  unsigned char D.16993;
  int D.16994;
  unsigned int D.16996;
  int D.16999;

  value.7 = (unsigned int) value;
  D.16989 = value.7 + 1;
  if (D.16989 <= 8) goto <D.16990>; else goto <D.16991>;
  <D.16990>:
  D.16992 = (unsigned char) value;
  D.16993 = D.16992 + 22;
  D.16994 = (int) D.16993;
  mono_mb_emit_byte (mb, D.16994);
  goto <D.16995>;
  <D.16991>:
  value.7 = (unsigned int) value;
  D.16996 = value.7 + 128;
  if (D.16996 <= 255) goto <D.16997>; else goto <D.16998>;
  <D.16997>:
  mono_mb_emit_byte (mb, 31);
  D.16992 = (unsigned char) value;
  D.16999 = (int) D.16992;
  mono_mb_emit_byte (mb, D.16999);
  goto <D.17000>;
  <D.16998>:
  mono_mb_emit_byte (mb, 32);
  mono_mb_emit_i4 (mb, value);
  <D.17000>:
  <D.16995>:
}


mono_mb_get_label (struct MonoMethodBuilder * mb)
{
  int D.17001;
  unsigned int D.17002;

  D.17002 = mb->pos;
  D.17001 = (int) D.17002;
  return D.17001;
}


mono_mb_get_pos (struct MonoMethodBuilder * mb)
{
  int D.17004;
  unsigned int D.17005;

  D.17005 = mb->pos;
  D.17004 = (int) D.17005;
  return D.17004;
}


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

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


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

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


mono_mb_emit_branch_label (struct MonoMethodBuilder * mb, guint8 op, guint32 label)
{
  int D.17013;
  unsigned int D.17014;
  unsigned int D.17015;
  unsigned int D.17016;
  int D.17017;

  D.17013 = (int) op;
  mono_mb_emit_byte (mb, D.17013);
  D.17014 = mb->pos;
  D.17015 = label - D.17014;
  D.17016 = D.17015 + 4294967292;
  D.17017 = (int) D.17016;
  mono_mb_emit_i4 (mb, D.17017);
}


mono_mb_patch_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  unsigned int D.17018;
  unsigned int D.17019;
  unsigned int D.17020;
  int D.17021;
  int pos.8;

  D.17018 = mb->pos;
  D.17019 = D.17018 - pos;
  D.17020 = D.17019 + 4294967292;
  D.17021 = (int) D.17020;
  pos.8 = (int) pos;
  mono_mb_patch_addr (mb, pos.8, D.17021);
}


mono_mb_patch_short_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  unsigned int D.17023;
  unsigned char D.17024;
  unsigned char D.17025;
  unsigned char D.17026;
  unsigned char D.17027;
  signed char D.17028;
  int D.17029;
  int pos.9;

  D.17023 = mb->pos;
  D.17024 = (unsigned char) D.17023;
  D.17025 = (unsigned char) pos;
  D.17026 = D.17024 - D.17025;
  D.17027 = D.17026 + 255;
  D.17028 = (signed char) D.17027;
  D.17029 = (int) D.17028;
  pos.9 = (int) pos;
  mono_mb_patch_addr_s (mb, pos.9, D.17029);
}


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.17031;
  _Bool D.17032;
  long int D.17033;
  long int D.17034;
  struct MonoMethod * ctor;
  struct MonoClass * mme;

  ctor = 0B;
  D.17031 = mono_defaults.corlib;
  mme = mono_class_from_name (D.17031, exc_nspace, exc_name);
  mono_class_init (mme);
  ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
  D.17032 = ctor == 0B;
  D.17033 = (long int) D.17032;
  D.17034 = __builtin_expect (D.17033, 0);
  if (D.17034 != 0) goto <D.17035>; else goto <D.17036>;
  <D.17035>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 535, "ctor");
  <D.17036>:
  mono_mb_emit_op (mb, 115, ctor);
  if (msg != 0B) goto <D.17037>; else goto <D.17038>;
  <D.17037>:
  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.17038>:
  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.17039;

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


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;
}