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

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


mono_mb_new_base (struct MonoClass * klass, MonoWrapperType type)
{
  _Bool D.17633;
  long int D.17634;
  long int D.17635;
  unsigned char D.17638;
  <unnamed-unsigned:5> D.17639;
  unsigned int D.17640;
  long unsigned int D.17641;
  void * D.17642;
  struct MonoMethodBuilder * D.17643;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * m;

  D.17633 = klass == 0B;
  D.17634 = (long int) D.17633;
  D.17635 = __builtin_expect (D.17634, 0);
  if (D.17635 != 0) goto <D.17636>; else goto <D.17637>;
  <D.17636>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 57, "klass != NULL");
  <D.17637>:
  mb = monoeg_malloc0 (88);
  m = monoeg_malloc0 (56);
  mb->method = m;
  m->klass = klass;
  m->inline_info = 1;
  D.17638 = (unsigned char) type;
  D.17639 = (<unnamed-unsigned:5>) D.17638;
  m->wrapper_type = D.17639;
  mb->code_size = 40;
  D.17640 = mb->code_size;
  D.17641 = (long unsigned int) D.17640;
  D.17642 = monoeg_malloc (D.17641);
  mb->code = D.17642;
  mono_mb_add_data (mb, 0B);
  D.17643 = mb;
  return D.17643;
}


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

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


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

  if (str != 0B) goto <D.17648>; else goto <D.17649>;
  <D.17648>:
  D.17650 = __strdup (str);
  return D.17650;
  <D.17649>:
  D.17650 = 0B;
  return D.17650;
}


mono_mb_free (struct MonoMethodBuilder * mb)
{
  struct GList * D.17652;
  int D.17653;
  struct MonoMethod * D.17656;
  int D.17657;
  char * D.17660;
  unsigned char * D.17661;

  D.17652 = mb->locals_list;
  monoeg_g_list_free (D.17652);
  D.17653 = mb->dynamic;
  if (D.17653 == 0) goto <D.17654>; else goto <D.17655>;
  <D.17654>:
  D.17656 = mb->method;
  monoeg_g_free (D.17656);
  D.17657 = mb->no_dup_name;
  if (D.17657 == 0) goto <D.17658>; else goto <D.17659>;
  <D.17658>:
  D.17660 = mb->name;
  monoeg_g_free (D.17660);
  <D.17659>:
  D.17661 = mb->code;
  monoeg_g_free (D.17661);
  <D.17655>:
  monoeg_g_free (mb);
}


mono_mb_create_method (struct MonoMethodBuilder * mb, struct MonoMethodSignature * signature, int max_stack)
{
  _Bool D.17662;
  long int D.17663;
  long int D.17664;
  struct MonoMethod * D.17667;
  struct MonoClass * D.17668;
  int D.17669;
  char * D.17672;
  int D.17673;
  long unsigned int D.17674;
  long unsigned int D.17675;
  long unsigned int D.17676;
  unsigned char * D.17677;
  void * D.17678;
  struct MonoType * D.17679;
  int D.17681;
  char * D.17685;
  unsigned int D.17686;
  unsigned int D.17687;
  unsigned int D.17688;
  void * D.17689;
  const unsigned char * D.17690;
  long unsigned int D.17691;
  long unsigned int D.17692;
  long unsigned int D.17693;
  short unsigned int D.17696;
  short unsigned int D.17697;
  short unsigned int D.17700;
  <unnamed-unsigned:15> D.17701;
  short unsigned int D.17702;
  int D.17703;
  short unsigned int D.17704;
  <unnamed-unsigned:15> D.17705;
  struct MonoExceptionClause * D.17706;
  int D.17707;
  unsigned char D.17708;
  <unnamed-unsigned:1> D.17709;
  void * D.17710;
  unsigned int D.17711;
  long unsigned int D.17714;
  long unsigned int D.17715;
  int D.17718;
  long unsigned int D.17719;
  long unsigned int D.17720;
  unsigned int D.17722;
  unsigned int D.17723;
  long unsigned int D.17724;
  void * D.17725;
  int i.0;
  long unsigned int D.17727;
  long unsigned int D.17728;
  void * * D.17729;
  void * D.17730;
  const char * * D.17731;
  short unsigned int D.17734;
  unsigned int D.17735;
  unsigned int D.17736;
  long unsigned int D.17737;
  char * * D.17738;
  const char * * D.17739;
  const char * D.17740;
  char * D.17741;
  int D.17742;
  struct GHashTable * D.17743;
  struct GHashTable * D.17746;
  struct MonoMethod * D.17747;
  struct MonoMethodHeader * header;
  struct MonoMethodWrapper * mw;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct GList * l;
  int i;

  D.17662 = mb == 0B;
  D.17663 = (long int) D.17662;
  D.17664 = __builtin_expect (D.17663, 0);
  if (D.17664 != 0) goto <D.17665>; else goto <D.17666>;
  <D.17665>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 132, "mb != NULL");
  <D.17666>:
  D.17667 = mb->method;
  D.17668 = D.17667->klass;
  image = D.17668->image;
  D.17669 = mb->dynamic;
  if (D.17669 != 0) goto <D.17670>; else goto <D.17671>;
  <D.17670>:
  method = mb->method;
  mw = method;
  D.17672 = mb->name;
  method->name = D.17672;
  method->dynamic = 1;
  D.17673 = mb->locals;
  D.17674 = (long unsigned int) D.17673;
  D.17675 = D.17674 + 4;
  D.17676 = D.17675 * 8;
  header = monoeg_malloc0 (D.17676);
  mw->header = header;
  D.17677 = mb->code;
  header->code = D.17677;
  i = 0;
  l = mb->locals_list;
  goto <D.17469>;
  <D.17468>:
  D.17678 = l->data;
  D.17679 = mono_metadata_type_dup (0B, D.17678);
  header->locals[i] = D.17679;
  l = l->next;
  i = i + 1;
  <D.17469>:
  if (l != 0B) goto <D.17468>; else goto <D.17470>;
  <D.17470>:
  goto <D.17680>;
  <D.17671>:
  method = mono_image_alloc0 (image, 56);
  D.17667 = mb->method;
  memcpy (method, D.17667, 56);
  mw = method;
  D.17681 = mb->no_dup_name;
  if (D.17681 != 0) goto <D.17682>; else goto <D.17683>;
  <D.17682>:
  D.17672 = mb->name;
  method->name = D.17672;
  goto <D.17684>;
  <D.17683>:
  D.17672 = mb->name;
  D.17685 = mono_image_strdup (image, D.17672);
  method->name = D.17685;
  <D.17684>:
  D.17673 = mb->locals;
  D.17674 = (long unsigned int) D.17673;
  D.17675 = D.17674 + 4;
  D.17686 = (unsigned int) D.17675;
  D.17687 = D.17686 * 8;
  header = mono_image_alloc0 (image, D.17687);
  mw->header = header;
  D.17688 = mb->pos;
  D.17689 = mono_image_alloc (image, D.17688);
  header->code = D.17689;
  D.17690 = header->code;
  D.17677 = mb->code;
  D.17688 = mb->pos;
  D.17691 = (long unsigned int) D.17688;
  memcpy (D.17690, D.17677, D.17691);
  i = 0;
  l = mb->locals_list;
  goto <D.17472>;
  <D.17471>:
  D.17678 = l->data;
  header->locals[i] = D.17678;
  l = l->next;
  i = i + 1;
  <D.17472>:
  if (l != 0B) goto <D.17471>; else goto <D.17473>;
  <D.17473>:
  <D.17680>:
  method->signature = signature;
  D.17692 = BIT_FIELD_REF <*signature, 64, 64>;
  D.17693 = D.17692 & 18014398509481984;
  if (D.17693 == 0) goto <D.17694>; else goto <D.17695>;
  <D.17694>:
  D.17696 = method->flags;
  D.17697 = D.17696 | 16;
  method->flags = D.17697;
  <D.17695>:
  if (max_stack <= 7) goto <D.17698>; else goto <D.17699>;
  <D.17698>:
  max_stack = 8;
  <D.17699>:
  D.17700 = (short unsigned int) max_stack;
  D.17701 = (<unnamed-unsigned:15>) D.17700;
  header->max_stack = D.17701;
  D.17688 = mb->pos;
  header->code_size = D.17688;
  D.17673 = mb->locals;
  D.17702 = (short unsigned int) D.17673;
  header->num_locals = D.17702;
  header->init_locals = 1;
  D.17703 = mb->num_clauses;
  D.17704 = (short unsigned int) D.17703;
  D.17705 = (<unnamed-unsigned:15>) D.17704;
  header->num_clauses = D.17705;
  D.17706 = mb->clauses;
  header->clauses = D.17706;
  D.17707 = mb->skip_visibility;
  D.17708 = (unsigned char) D.17707;
  D.17709 = (<unnamed-unsigned:1>) D.17708;
  method->skip_visibility = D.17709;
  D.17710 = mw->method_data;
  D.17711 = monoeg_g_list_length (D.17710);
  i = (int) D.17711;
  if (i != 0) goto <D.17712>; else goto <D.17713>;
  <D.17712>:
  {
    struct GList * tmp;
    void * * data;

    D.17710 = mw->method_data;
    l = monoeg_g_list_reverse (D.17710);
    D.17714 = BIT_FIELD_REF <*method, 64, 256>;
    D.17715 = D.17714 & 512;
    if (D.17715 != 0) goto <D.17716>; else goto <D.17717>;
    <D.17716>:
    D.17718 = i + 1;
    D.17719 = (long unsigned int) D.17718;
    D.17720 = D.17719 * 8;
    data = monoeg_malloc (D.17720);
    goto <D.17721>;
    <D.17717>:
    D.17718 = i + 1;
    D.17719 = (long unsigned int) D.17718;
    D.17722 = (unsigned int) D.17719;
    D.17723 = D.17722 * 8;
    data = mono_image_alloc (image, D.17723);
    <D.17721>:
    D.17724 = (long unsigned int) i;
    D.17725 = (void *) D.17724;
    *data = D.17725;
    i = 1;
    tmp = l;
    goto <D.17477>;
    <D.17476>:
    i.0 = i;
    i = i.0 + 1;
    D.17727 = (long unsigned int) i.0;
    D.17728 = D.17727 * 8;
    D.17729 = data + D.17728;
    D.17730 = tmp->data;
    *D.17729 = D.17730;
    tmp = tmp->next;
    <D.17477>:
    if (tmp != 0B) goto <D.17476>; else goto <D.17478>;
    <D.17478>:
    monoeg_g_list_free (l);
    mw->method_data = data;
  }
  <D.17713>:
  D.17731 = mb->param_names;
  if (D.17731 != 0B) goto <D.17732>; else goto <D.17733>;
  <D.17732>:
  {
    char * * param_names;

    D.17734 = signature->param_count;
    D.17735 = (unsigned int) D.17734;
    D.17736 = D.17735 * 8;
    param_names = mono_image_alloc0 (image, D.17736);
    i = 0;
    goto <D.17481>;
    <D.17480>:
    D.17724 = (long unsigned int) i;
    D.17737 = D.17724 * 8;
    D.17738 = param_names + D.17737;
    D.17731 = mb->param_names;
    D.17724 = (long unsigned int) i;
    D.17737 = D.17724 * 8;
    D.17739 = D.17731 + D.17737;
    D.17740 = *D.17739;
    D.17741 = mono_image_strdup (image, D.17740);
    *D.17738 = D.17741;
    i = i + 1;
    <D.17481>:
    D.17734 = signature->param_count;
    D.17742 = (int) D.17734;
    if (D.17742 > i) goto <D.17480>; else goto <D.17482>;
    <D.17482>:
    mono_image_lock (image);
    D.17743 = image->wrapper_param_names;
    if (D.17743 == 0B) goto <D.17744>; else goto <D.17745>;
    <D.17744>:
    D.17746 = monoeg_g_hash_table_new (0B, 0B);
    image->wrapper_param_names = D.17746;
    <D.17745>:
    D.17743 = image->wrapper_param_names;
    monoeg_g_hash_table_insert_replace (D.17743, method, param_names, 0);
    mono_image_unlock (image);
  }
  <D.17733>:
  D.17747 = method;
  return D.17747;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17749;
  long unsigned int D.17750;

  D.17750 = __builtin_object_size (__dest, 0);
  D.17749 = __builtin___memcpy_chk (__dest, __src, __len, D.17750);
  return D.17749;
}


mono_mb_add_data (struct MonoMethodBuilder * mb, void * data)
{
  _Bool D.17752;
  long int D.17753;
  long int D.17754;
  void * D.17757;
  struct GList * D.17758;
  guint32 D.17759;
  struct MonoMethodWrapper * mw;

  D.17752 = mb == 0B;
  D.17753 = (long int) D.17752;
  D.17754 = __builtin_expect (D.17753, 0);
  if (D.17754 != 0) goto <D.17755>; else goto <D.17756>;
  <D.17755>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 254, "mb != NULL");
  <D.17756>:
  mw = mb->method;
  D.17757 = mw->method_data;
  D.17758 = monoeg_g_list_prepend (D.17757, data);
  mw->method_data = D.17758;
  D.17757 = mw->method_data;
  D.17759 = monoeg_g_list_length (D.17757);
  return D.17759;
}


mono_mb_add_local (struct MonoMethodBuilder * mb, struct MonoType * type)
{
  _Bool D.17761;
  long int D.17762;
  long int D.17763;
  _Bool D.17766;
  long int D.17767;
  long int D.17768;
  struct GList * D.17771;
  struct GList * D.17772;
  int D.17773;
  int D.17774;
  int D.17775;
  int res;

  D.17761 = mb == 0B;
  D.17762 = (long int) D.17761;
  D.17763 = __builtin_expect (D.17762, 0);
  if (D.17763 != 0) goto <D.17764>; else goto <D.17765>;
  <D.17764>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 271, "mb != NULL");
  <D.17765>:
  D.17766 = type == 0B;
  D.17767 = (long int) D.17766;
  D.17768 = __builtin_expect (D.17767, 0);
  if (D.17768 != 0) goto <D.17769>; else goto <D.17770>;
  <D.17769>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 272, "type != NULL");
  <D.17770>:
  res = mb->locals;
  D.17771 = mb->locals_list;
  D.17772 = monoeg_g_list_append (D.17771, type);
  mb->locals_list = D.17772;
  D.17773 = mb->locals;
  D.17774 = D.17773 + 1;
  mb->locals = D.17774;
  D.17775 = res;
  return D.17775;
}


mono_mb_patch_addr (struct MonoMethodBuilder * mb, int pos, int value)
{
  unsigned char * D.17777;
  sizetype D.17778;
  unsigned char * D.17779;
  unsigned char D.17780;
  sizetype D.17781;
  unsigned char * D.17782;
  int D.17783;
  unsigned char D.17784;
  sizetype D.17785;
  unsigned char * D.17786;
  int D.17787;
  unsigned char D.17788;
  sizetype D.17789;
  unsigned char * D.17790;
  unsigned int value.1;
  unsigned int D.17792;
  unsigned char D.17793;

  D.17777 = mb->code;
  D.17778 = (sizetype) pos;
  D.17779 = D.17777 + D.17778;
  D.17780 = (unsigned char) value;
  *D.17779 = D.17780;
  D.17777 = mb->code;
  D.17778 = (sizetype) pos;
  D.17781 = D.17778 + 1;
  D.17782 = D.17777 + D.17781;
  D.17783 = value >> 8;
  D.17784 = (unsigned char) D.17783;
  *D.17782 = D.17784;
  D.17777 = mb->code;
  D.17778 = (sizetype) pos;
  D.17785 = D.17778 + 2;
  D.17786 = D.17777 + D.17785;
  D.17787 = value >> 16;
  D.17788 = (unsigned char) D.17787;
  *D.17786 = D.17788;
  D.17777 = mb->code;
  D.17778 = (sizetype) pos;
  D.17789 = D.17778 + 3;
  D.17790 = D.17777 + D.17789;
  value.1 = (unsigned int) value;
  D.17792 = value.1 >> 24;
  D.17793 = (unsigned char) D.17792;
  *D.17790 = D.17793;
}


mono_mb_patch_addr_s (struct MonoMethodBuilder * mb, int pos, gint8 value)
{
  unsigned char * D.17794;
  sizetype D.17795;
  gint8 * D.17796;

  D.17794 = mb->code;
  D.17795 = (sizetype) pos;
  D.17796 = D.17794 + D.17795;
  *D.17796 = value;
}


mono_mb_emit_byte (struct MonoMethodBuilder * mb, guint8 op)
{
  unsigned int D.17797;
  unsigned int D.17798;
  unsigned int D.17801;
  unsigned int D.17802;
  unsigned char * D.17803;
  long unsigned int D.17804;
  void * D.17805;
  unsigned int D.17806;
  unsigned int D.17807;
  sizetype D.17808;
  unsigned char * D.17809;

  D.17797 = mb->pos;
  D.17798 = mb->code_size;
  if (D.17797 >= D.17798) goto <D.17799>; else goto <D.17800>;
  <D.17799>:
  D.17798 = mb->code_size;
  D.17798 = mb->code_size;
  D.17801 = D.17798 >> 1;
  D.17802 = D.17798 + D.17801;
  mb->code_size = D.17802;
  D.17803 = mb->code;
  D.17798 = mb->code_size;
  D.17804 = (long unsigned int) D.17798;
  D.17805 = monoeg_realloc (D.17803, D.17804);
  mb->code = D.17805;
  <D.17800>:
  D.17803 = mb->code;
  D.17797 = mb->pos;
  D.17806 = D.17797;
  D.17807 = D.17806 + 1;
  mb->pos = D.17807;
  D.17808 = (sizetype) D.17806;
  D.17809 = D.17803 + D.17808;
  *D.17809 = 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.17810>; else goto <D.17811>;
  <D.17810>:
  mono_mb_emit_icon (mb, offset);
  mono_mb_emit_byte (mb, 88);
  <D.17811>:
}


mono_mb_emit_i4 (struct MonoMethodBuilder * mb, gint32 data)
{
  unsigned int D.17812;
  unsigned int D.17813;
  unsigned int D.17814;
  unsigned int D.17817;
  unsigned int D.17818;
  unsigned char * D.17819;
  long unsigned int D.17820;
  void * D.17821;
  int D.17822;

  D.17812 = mb->pos;
  D.17813 = D.17812 + 4;
  D.17814 = mb->code_size;
  if (D.17813 >= D.17814) goto <D.17815>; else goto <D.17816>;
  <D.17815>:
  D.17814 = mb->code_size;
  D.17814 = mb->code_size;
  D.17817 = D.17814 >> 1;
  D.17818 = D.17814 + D.17817;
  mb->code_size = D.17818;
  D.17819 = mb->code;
  D.17814 = mb->code_size;
  D.17820 = (long unsigned int) D.17814;
  D.17821 = monoeg_realloc (D.17819, D.17820);
  mb->code = D.17821;
  <D.17816>:
  D.17812 = mb->pos;
  D.17822 = (int) D.17812;
  mono_mb_patch_addr (mb, D.17822, data);
  D.17812 = mb->pos;
  D.17813 = D.17812 + 4;
  mb->pos = D.17813;
}


mono_mb_emit_i2 (struct MonoMethodBuilder * mb, gint16 data)
{
  unsigned int D.17823;
  unsigned int D.17824;
  unsigned int D.17825;
  unsigned int D.17828;
  unsigned int D.17829;
  unsigned char * D.17830;
  long unsigned int D.17831;
  void * D.17832;
  sizetype D.17833;
  unsigned char * D.17834;
  unsigned char D.17835;
  unsigned int D.17836;
  sizetype D.17837;
  unsigned char * D.17838;
  short int D.17839;
  unsigned char D.17840;

  D.17823 = mb->pos;
  D.17824 = D.17823 + 2;
  D.17825 = mb->code_size;
  if (D.17824 >= D.17825) goto <D.17826>; else goto <D.17827>;
  <D.17826>:
  D.17825 = mb->code_size;
  D.17825 = mb->code_size;
  D.17828 = D.17825 >> 1;
  D.17829 = D.17825 + D.17828;
  mb->code_size = D.17829;
  D.17830 = mb->code;
  D.17825 = mb->code_size;
  D.17831 = (long unsigned int) D.17825;
  D.17832 = monoeg_realloc (D.17830, D.17831);
  mb->code = D.17832;
  <D.17827>:
  D.17830 = mb->code;
  D.17823 = mb->pos;
  D.17833 = (sizetype) D.17823;
  D.17834 = D.17830 + D.17833;
  D.17835 = (unsigned char) data;
  *D.17834 = D.17835;
  D.17830 = mb->code;
  D.17823 = mb->pos;
  D.17836 = D.17823 + 1;
  D.17837 = (sizetype) D.17836;
  D.17838 = D.17830 + D.17837;
  D.17839 = data >> 8;
  D.17840 = (unsigned char) D.17839;
  *D.17838 = D.17840;
  D.17823 = mb->pos;
  D.17824 = D.17823 + 2;
  mb->pos = D.17824;
}


mono_mb_emit_op (struct MonoMethodBuilder * mb, guint8 op, void * data)
{
  unsigned int D.17841;
  int D.17842;

  mono_mb_emit_byte (mb, op);
  D.17841 = mono_mb_add_data (mb, data);
  D.17842 = (int) D.17841;
  mono_mb_emit_i4 (mb, D.17842);
}


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.17845;
  unsigned char D.17846;
  short int D.17851;

  if (argnum <= 3) goto <D.17843>; else goto <D.17844>;
  <D.17843>:
  D.17845 = (unsigned char) argnum;
  D.17846 = D.17845 + 2;
  mono_mb_emit_byte (mb, D.17846);
  goto <D.17847>;
  <D.17844>:
  if (argnum <= 255) goto <D.17848>; else goto <D.17849>;
  <D.17848>:
  mono_mb_emit_byte (mb, 14);
  D.17845 = (unsigned char) argnum;
  mono_mb_emit_byte (mb, D.17845);
  goto <D.17850>;
  <D.17849>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 9);
  D.17851 = (short int) argnum;
  mono_mb_emit_i2 (mb, D.17851);
  <D.17850>:
  <D.17847>:
}


mono_mb_emit_ldarg_addr (struct MonoMethodBuilder * mb, guint argnum)
{
  unsigned char D.17854;
  short int D.17856;

  if (argnum <= 255) goto <D.17852>; else goto <D.17853>;
  <D.17852>:
  mono_mb_emit_byte (mb, 15);
  D.17854 = (unsigned char) argnum;
  mono_mb_emit_byte (mb, D.17854);
  goto <D.17855>;
  <D.17853>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 10);
  D.17856 = (short int) argnum;
  mono_mb_emit_i2 (mb, D.17856);
  <D.17855>:
}


mono_mb_emit_ldloc_addr (struct MonoMethodBuilder * mb, guint locnum)
{
  unsigned char D.17859;
  short int D.17861;

  if (locnum <= 255) goto <D.17857>; else goto <D.17858>;
  <D.17857>:
  mono_mb_emit_byte (mb, 18);
  D.17859 = (unsigned char) locnum;
  mono_mb_emit_byte (mb, D.17859);
  goto <D.17860>;
  <D.17858>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 13);
  D.17861 = (short int) locnum;
  mono_mb_emit_i2 (mb, D.17861);
  <D.17860>:
}


mono_mb_emit_ldloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.17864;
  unsigned char D.17865;
  short int D.17870;

  if (num <= 3) goto <D.17862>; else goto <D.17863>;
  <D.17862>:
  D.17864 = (unsigned char) num;
  D.17865 = D.17864 + 6;
  mono_mb_emit_byte (mb, D.17865);
  goto <D.17866>;
  <D.17863>:
  if (num <= 255) goto <D.17867>; else goto <D.17868>;
  <D.17867>:
  mono_mb_emit_byte (mb, 17);
  D.17864 = (unsigned char) num;
  mono_mb_emit_byte (mb, D.17864);
  goto <D.17869>;
  <D.17868>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 12);
  D.17870 = (short int) num;
  mono_mb_emit_i2 (mb, D.17870);
  <D.17869>:
  <D.17866>:
}


mono_mb_emit_stloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.17873;
  unsigned char D.17874;
  short int D.17879;

  if (num <= 3) goto <D.17871>; else goto <D.17872>;
  <D.17871>:
  D.17873 = (unsigned char) num;
  D.17874 = D.17873 + 10;
  mono_mb_emit_byte (mb, D.17874);
  goto <D.17875>;
  <D.17872>:
  if (num <= 255) goto <D.17876>; else goto <D.17877>;
  <D.17876>:
  mono_mb_emit_byte (mb, 19);
  D.17873 = (unsigned char) num;
  mono_mb_emit_byte (mb, D.17873);
  goto <D.17878>;
  <D.17877>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 14);
  D.17879 = (short int) num;
  mono_mb_emit_i2 (mb, D.17879);
  <D.17878>:
  <D.17875>:
}


mono_mb_emit_icon (struct MonoMethodBuilder * mb, gint32 value)
{
  unsigned int value.2;
  unsigned int D.17881;
  unsigned char D.17884;
  unsigned char D.17885;
  unsigned int D.17887;

  value.2 = (unsigned int) value;
  D.17881 = value.2 + 1;
  if (D.17881 <= 8) goto <D.17882>; else goto <D.17883>;
  <D.17882>:
  D.17884 = (unsigned char) value;
  D.17885 = D.17884 + 22;
  mono_mb_emit_byte (mb, D.17885);
  goto <D.17886>;
  <D.17883>:
  value.2 = (unsigned int) value;
  D.17887 = value.2 + 128;
  if (D.17887 <= 255) goto <D.17888>; else goto <D.17889>;
  <D.17888>:
  mono_mb_emit_byte (mb, 31);
  D.17884 = (unsigned char) value;
  mono_mb_emit_byte (mb, D.17884);
  goto <D.17890>;
  <D.17889>:
  mono_mb_emit_byte (mb, 32);
  mono_mb_emit_i4 (mb, value);
  <D.17890>:
  <D.17886>:
}


mono_mb_get_label (struct MonoMethodBuilder * mb)
{
  int D.17891;
  unsigned int D.17892;

  D.17892 = mb->pos;
  D.17891 = (int) D.17892;
  return D.17891;
}


mono_mb_get_pos (struct MonoMethodBuilder * mb)
{
  int D.17894;
  unsigned int D.17895;

  D.17895 = mb->pos;
  D.17894 = (int) D.17895;
  return D.17894;
}


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

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


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

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


mono_mb_emit_branch_label (struct MonoMethodBuilder * mb, guint8 op, guint32 label)
{
  unsigned int D.17901;
  unsigned int D.17902;
  unsigned int D.17903;
  int D.17904;

  mono_mb_emit_byte (mb, op);
  D.17901 = mb->pos;
  D.17902 = label - D.17901;
  D.17903 = D.17902 + 4294967292;
  D.17904 = (int) D.17903;
  mono_mb_emit_i4 (mb, D.17904);
}


mono_mb_patch_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.3;
  unsigned int D.17906;
  unsigned int D.17907;
  unsigned int D.17908;
  int D.17909;

  pos.3 = (int) pos;
  D.17906 = mb->pos;
  D.17907 = D.17906 - pos;
  D.17908 = D.17907 + 4294967292;
  D.17909 = (int) D.17908;
  mono_mb_patch_addr (mb, pos.3, D.17909);
}


mono_mb_patch_short_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.4;
  unsigned int D.17911;
  unsigned char D.17912;
  unsigned char D.17913;
  unsigned char D.17914;
  unsigned char D.17915;
  signed char D.17916;

  pos.4 = (int) pos;
  D.17911 = mb->pos;
  D.17912 = (unsigned char) D.17911;
  D.17913 = (unsigned char) pos;
  D.17914 = D.17912 - D.17913;
  D.17915 = D.17914 + 255;
  D.17916 = (signed char) D.17915;
  mono_mb_patch_addr_s (mb, pos.4, D.17916);
}


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.17917;
  _Bool D.17918;
  long int D.17919;
  long int D.17920;
  struct MonoMethod * ctor;
  struct MonoClass * mme;

  ctor = 0B;
  D.17917 = mono_defaults.corlib;
  mme = mono_class_from_name (D.17917, exc_nspace, exc_name);
  mono_class_init (mme);
  ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
  D.17918 = ctor == 0B;
  D.17919 = (long int) D.17918;
  D.17920 = __builtin_expect (D.17919, 0);
  if (D.17920 != 0) goto <D.17921>; else goto <D.17922>;
  <D.17921>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 535, "ctor");
  <D.17922>:
  mono_mb_emit_op (mb, 115, ctor);
  if (msg != 0B) goto <D.17923>; else goto <D.17924>;
  <D.17923>:
  mono_mb_emit_byte (mb, 37);
  mono_mb_emit_ldflda (mb, 32);
  mono_mb_emit_ldstr (mb, msg);
  mono_mb_emit_byte (mb, 81);
  <D.17924>:
  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.17925;

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


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