__attribute__((visibility ("hidden")))
mono_mb_new_no_dup_name (struct MonoClass * klass, const char * name, MonoWrapperType type)
{
  struct MonoMethodBuilder * D.17245;
  struct MonoMethodBuilder * mb;

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


mono_mb_new_base (struct MonoClass * klass, MonoWrapperType type)
{
  _Bool D.17247;
  long int D.17248;
  long int D.17249;
  unsigned char D.17252;
  <unnamed-unsigned:5> D.17253;
  unsigned int D.17254;
  long unsigned int D.17255;
  void * D.17256;
  struct MonoMethodBuilder * D.17257;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * m;

  D.17247 = klass == 0B;
  D.17248 = (long int) D.17247;
  D.17249 = __builtin_expect (D.17248, 0);
  if (D.17249 != 0) goto <D.17250>; else goto <D.17251>;
  <D.17250>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 57, "klass != NULL");
  <D.17251>:
  mb = monoeg_malloc0 (88);
  m = monoeg_malloc0 (56);
  mb->method = m;
  m->klass = klass;
  m->inline_info = 1;
  D.17252 = (unsigned char) type;
  D.17253 = (<unnamed-unsigned:5>) D.17252;
  m->wrapper_type = D.17253;
  mb->code_size = 40;
  D.17254 = mb->code_size;
  D.17255 = (long unsigned int) D.17254;
  D.17256 = monoeg_malloc (D.17255);
  mb->code = D.17256;
  mono_mb_add_data (mb, 0B);
  D.17257 = mb;
  return D.17257;
}


__attribute__((visibility ("hidden")))
mono_mb_new (struct MonoClass * klass, const char * name, MonoWrapperType type)
{
  gchar * D.17259;
  struct MonoMethodBuilder * D.17260;
  struct MonoMethodBuilder * mb;

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


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

  if (str != 0B) goto <D.17262>; else goto <D.17263>;
  <D.17262>:
  D.17264 = __strdup (str);
  return D.17264;
  <D.17263>:
  D.17264 = 0B;
  return D.17264;
}


__attribute__((visibility ("hidden")))
mono_mb_free (struct MonoMethodBuilder * mb)
{
  struct GList * D.17266;
  int D.17267;
  struct MonoMethod * D.17270;
  int D.17271;
  char * D.17274;
  unsigned char * D.17275;

  D.17266 = mb->locals_list;
  monoeg_g_list_free (D.17266);
  D.17267 = mb->dynamic;
  if (D.17267 == 0) goto <D.17268>; else goto <D.17269>;
  <D.17268>:
  D.17270 = mb->method;
  monoeg_g_free (D.17270);
  D.17271 = mb->no_dup_name;
  if (D.17271 == 0) goto <D.17272>; else goto <D.17273>;
  <D.17272>:
  D.17274 = mb->name;
  monoeg_g_free (D.17274);
  <D.17273>:
  D.17275 = mb->code;
  monoeg_g_free (D.17275);
  <D.17269>:
  monoeg_g_free (mb);
}


__attribute__((visibility ("hidden")))
mono_mb_create_method (struct MonoMethodBuilder * mb, struct MonoMethodSignature * signature, int max_stack)
{
  _Bool D.17276;
  long int D.17277;
  long int D.17278;
  struct MonoMethod * D.17281;
  struct MonoClass * D.17282;
  int D.17283;
  char * D.17286;
  int D.17287;
  long unsigned int D.17288;
  long unsigned int D.17289;
  long unsigned int D.17290;
  unsigned char * D.17291;
  void * D.17292;
  struct MonoType * D.17293;
  int D.17295;
  char * D.17299;
  unsigned int D.17300;
  unsigned int D.17301;
  unsigned int D.17302;
  void * D.17303;
  const unsigned char * D.17304;
  long unsigned int D.17305;
  long unsigned int D.17306;
  long unsigned int D.17307;
  short unsigned int D.17310;
  short unsigned int D.17311;
  short unsigned int D.17314;
  <unnamed-unsigned:15> D.17315;
  short unsigned int D.17316;
  int D.17317;
  short unsigned int D.17318;
  <unnamed-unsigned:15> D.17319;
  struct MonoExceptionClause * D.17320;
  int D.17321;
  unsigned char D.17322;
  <unnamed-unsigned:1> D.17323;
  void * D.17324;
  unsigned int D.17325;
  long unsigned int D.17328;
  long unsigned int D.17329;
  int D.17332;
  long unsigned int D.17333;
  long unsigned int D.17334;
  unsigned int D.17336;
  unsigned int D.17337;
  long unsigned int D.17338;
  void * D.17339;
  int i.0;
  long unsigned int D.17341;
  long unsigned int D.17342;
  void * * D.17343;
  void * D.17344;
  const char * * D.17345;
  short unsigned int D.17348;
  unsigned int D.17349;
  unsigned int D.17350;
  long unsigned int D.17351;
  char * * D.17352;
  const char * * D.17353;
  const char * D.17354;
  char * D.17355;
  int D.17356;
  struct GHashTable * D.17357;
  struct GHashTable * D.17360;
  struct MonoMethod * D.17361;
  struct MonoMethodHeader * header;
  struct MonoMethodWrapper * mw;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct GList * l;
  int i;

  D.17276 = mb == 0B;
  D.17277 = (long int) D.17276;
  D.17278 = __builtin_expect (D.17277, 0);
  if (D.17278 != 0) goto <D.17279>; else goto <D.17280>;
  <D.17279>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 132, "mb != NULL");
  <D.17280>:
  D.17281 = mb->method;
  D.17282 = D.17281->klass;
  image = D.17282->image;
  D.17283 = mb->dynamic;
  if (D.17283 != 0) goto <D.17284>; else goto <D.17285>;
  <D.17284>:
  method = mb->method;
  mw = method;
  D.17286 = mb->name;
  method->name = D.17286;
  method->dynamic = 1;
  D.17287 = mb->locals;
  D.17288 = (long unsigned int) D.17287;
  D.17289 = D.17288 + 4;
  D.17290 = D.17289 * 8;
  header = monoeg_malloc0 (D.17290);
  mw->header = header;
  D.17291 = mb->code;
  header->code = D.17291;
  i = 0;
  l = mb->locals_list;
  goto <D.17083>;
  <D.17082>:
  D.17292 = l->data;
  D.17293 = mono_metadata_type_dup (0B, D.17292);
  header->locals[i] = D.17293;
  l = l->next;
  i = i + 1;
  <D.17083>:
  if (l != 0B) goto <D.17082>; else goto <D.17084>;
  <D.17084>:
  goto <D.17294>;
  <D.17285>:
  method = mono_image_alloc0 (image, 56);
  D.17281 = mb->method;
  memcpy (method, D.17281, 56);
  mw = method;
  D.17295 = mb->no_dup_name;
  if (D.17295 != 0) goto <D.17296>; else goto <D.17297>;
  <D.17296>:
  D.17286 = mb->name;
  method->name = D.17286;
  goto <D.17298>;
  <D.17297>:
  D.17286 = mb->name;
  D.17299 = mono_image_strdup (image, D.17286);
  method->name = D.17299;
  <D.17298>:
  D.17287 = mb->locals;
  D.17288 = (long unsigned int) D.17287;
  D.17289 = D.17288 + 4;
  D.17300 = (unsigned int) D.17289;
  D.17301 = D.17300 * 8;
  header = mono_image_alloc0 (image, D.17301);
  mw->header = header;
  D.17302 = mb->pos;
  D.17303 = mono_image_alloc (image, D.17302);
  header->code = D.17303;
  D.17304 = header->code;
  D.17291 = mb->code;
  D.17302 = mb->pos;
  D.17305 = (long unsigned int) D.17302;
  memcpy (D.17304, D.17291, D.17305);
  i = 0;
  l = mb->locals_list;
  goto <D.17086>;
  <D.17085>:
  D.17292 = l->data;
  header->locals[i] = D.17292;
  l = l->next;
  i = i + 1;
  <D.17086>:
  if (l != 0B) goto <D.17085>; else goto <D.17087>;
  <D.17087>:
  <D.17294>:
  method->signature = signature;
  D.17306 = BIT_FIELD_REF <*signature, 64, 64>;
  D.17307 = D.17306 & 512;
  if (D.17307 == 0) goto <D.17308>; else goto <D.17309>;
  <D.17308>:
  D.17310 = method->flags;
  D.17311 = D.17310 | 16;
  method->flags = D.17311;
  <D.17309>:
  if (max_stack <= 7) goto <D.17312>; else goto <D.17313>;
  <D.17312>:
  max_stack = 8;
  <D.17313>:
  D.17314 = (short unsigned int) max_stack;
  D.17315 = (<unnamed-unsigned:15>) D.17314;
  header->max_stack = D.17315;
  D.17302 = mb->pos;
  header->code_size = D.17302;
  D.17287 = mb->locals;
  D.17316 = (short unsigned int) D.17287;
  header->num_locals = D.17316;
  header->init_locals = 1;
  D.17317 = mb->num_clauses;
  D.17318 = (short unsigned int) D.17317;
  D.17319 = (<unnamed-unsigned:15>) D.17318;
  header->num_clauses = D.17319;
  D.17320 = mb->clauses;
  header->clauses = D.17320;
  D.17321 = mb->skip_visibility;
  D.17322 = (unsigned char) D.17321;
  D.17323 = (<unnamed-unsigned:1>) D.17322;
  method->skip_visibility = D.17323;
  D.17324 = mw->method_data;
  D.17325 = monoeg_g_list_length (D.17324);
  i = (int) D.17325;
  if (i != 0) goto <D.17326>; else goto <D.17327>;
  <D.17326>:
  {
    struct GList * tmp;
    void * * data;

    D.17324 = mw->method_data;
    l = monoeg_g_list_reverse (D.17324);
    D.17328 = BIT_FIELD_REF <*method, 64, 256>;
    D.17329 = D.17328 & 18014398509481984;
    if (D.17329 != 0) goto <D.17330>; else goto <D.17331>;
    <D.17330>:
    D.17332 = i + 1;
    D.17333 = (long unsigned int) D.17332;
    D.17334 = D.17333 * 8;
    data = monoeg_malloc (D.17334);
    goto <D.17335>;
    <D.17331>:
    D.17332 = i + 1;
    D.17333 = (long unsigned int) D.17332;
    D.17336 = (unsigned int) D.17333;
    D.17337 = D.17336 * 8;
    data = mono_image_alloc (image, D.17337);
    <D.17335>:
    D.17338 = (long unsigned int) i;
    D.17339 = (void *) D.17338;
    *data = D.17339;
    i = 1;
    tmp = l;
    goto <D.17091>;
    <D.17090>:
    i.0 = i;
    i = i.0 + 1;
    D.17341 = (long unsigned int) i.0;
    D.17342 = D.17341 * 8;
    D.17343 = data + D.17342;
    D.17344 = tmp->data;
    *D.17343 = D.17344;
    tmp = tmp->next;
    <D.17091>:
    if (tmp != 0B) goto <D.17090>; else goto <D.17092>;
    <D.17092>:
    monoeg_g_list_free (l);
    mw->method_data = data;
  }
  <D.17327>:
  D.17345 = mb->param_names;
  if (D.17345 != 0B) goto <D.17346>; else goto <D.17347>;
  <D.17346>:
  {
    char * * param_names;

    D.17348 = signature->param_count;
    D.17349 = (unsigned int) D.17348;
    D.17350 = D.17349 * 8;
    param_names = mono_image_alloc0 (image, D.17350);
    i = 0;
    goto <D.17095>;
    <D.17094>:
    D.17338 = (long unsigned int) i;
    D.17351 = D.17338 * 8;
    D.17352 = param_names + D.17351;
    D.17345 = mb->param_names;
    D.17338 = (long unsigned int) i;
    D.17351 = D.17338 * 8;
    D.17353 = D.17345 + D.17351;
    D.17354 = *D.17353;
    D.17355 = mono_image_strdup (image, D.17354);
    *D.17352 = D.17355;
    i = i + 1;
    <D.17095>:
    D.17348 = signature->param_count;
    D.17356 = (int) D.17348;
    if (D.17356 > i) goto <D.17094>; else goto <D.17096>;
    <D.17096>:
    mono_image_lock (image);
    D.17357 = image->wrapper_param_names;
    if (D.17357 == 0B) goto <D.17358>; else goto <D.17359>;
    <D.17358>:
    D.17360 = monoeg_g_hash_table_new (0B, 0B);
    image->wrapper_param_names = D.17360;
    <D.17359>:
    D.17357 = image->wrapper_param_names;
    monoeg_g_hash_table_insert_replace (D.17357, method, param_names, 0);
    mono_image_unlock (image);
  }
  <D.17347>:
  D.17361 = method;
  return D.17361;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17363;
  long unsigned int D.17364;

  D.17364 = __builtin_object_size (__dest, 0);
  D.17363 = __builtin___memcpy_chk (__dest, __src, __len, D.17364);
  return D.17363;
}


__attribute__((visibility ("hidden")))
mono_mb_add_data (struct MonoMethodBuilder * mb, void * data)
{
  _Bool D.17366;
  long int D.17367;
  long int D.17368;
  void * D.17371;
  struct GList * D.17372;
  guint32 D.17373;
  struct MonoMethodWrapper * mw;

  D.17366 = mb == 0B;
  D.17367 = (long int) D.17366;
  D.17368 = __builtin_expect (D.17367, 0);
  if (D.17368 != 0) goto <D.17369>; else goto <D.17370>;
  <D.17369>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 254, "mb != NULL");
  <D.17370>:
  mw = mb->method;
  D.17371 = mw->method_data;
  D.17372 = monoeg_g_list_prepend (D.17371, data);
  mw->method_data = D.17372;
  D.17371 = mw->method_data;
  D.17373 = monoeg_g_list_length (D.17371);
  return D.17373;
}


__attribute__((visibility ("hidden")))
mono_mb_add_local (struct MonoMethodBuilder * mb, struct MonoType * type)
{
  _Bool D.17375;
  long int D.17376;
  long int D.17377;
  _Bool D.17380;
  long int D.17381;
  long int D.17382;
  struct GList * D.17385;
  struct GList * D.17386;
  int D.17387;
  int D.17388;
  int D.17389;
  int res;

  D.17375 = mb == 0B;
  D.17376 = (long int) D.17375;
  D.17377 = __builtin_expect (D.17376, 0);
  if (D.17377 != 0) goto <D.17378>; else goto <D.17379>;
  <D.17378>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 271, "mb != NULL");
  <D.17379>:
  D.17380 = type == 0B;
  D.17381 = (long int) D.17380;
  D.17382 = __builtin_expect (D.17381, 0);
  if (D.17382 != 0) goto <D.17383>; else goto <D.17384>;
  <D.17383>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 272, "type != NULL");
  <D.17384>:
  res = mb->locals;
  D.17385 = mb->locals_list;
  D.17386 = monoeg_g_list_append (D.17385, type);
  mb->locals_list = D.17386;
  D.17387 = mb->locals;
  D.17388 = D.17387 + 1;
  mb->locals = D.17388;
  D.17389 = res;
  return D.17389;
}


__attribute__((visibility ("hidden")))
mono_mb_patch_addr (struct MonoMethodBuilder * mb, int pos, int value)
{
  unsigned char * D.17391;
  sizetype D.17392;
  unsigned char * D.17393;
  unsigned char D.17394;
  sizetype D.17395;
  unsigned char * D.17396;
  int D.17397;
  unsigned char D.17398;
  sizetype D.17399;
  unsigned char * D.17400;
  int D.17401;
  unsigned char D.17402;
  sizetype D.17403;
  unsigned char * D.17404;
  unsigned int value.1;
  unsigned int D.17406;
  unsigned char D.17407;

  D.17391 = mb->code;
  D.17392 = (sizetype) pos;
  D.17393 = D.17391 + D.17392;
  D.17394 = (unsigned char) value;
  *D.17393 = D.17394;
  D.17391 = mb->code;
  D.17392 = (sizetype) pos;
  D.17395 = D.17392 + 1;
  D.17396 = D.17391 + D.17395;
  D.17397 = value >> 8;
  D.17398 = (unsigned char) D.17397;
  *D.17396 = D.17398;
  D.17391 = mb->code;
  D.17392 = (sizetype) pos;
  D.17399 = D.17392 + 2;
  D.17400 = D.17391 + D.17399;
  D.17401 = value >> 16;
  D.17402 = (unsigned char) D.17401;
  *D.17400 = D.17402;
  D.17391 = mb->code;
  D.17392 = (sizetype) pos;
  D.17403 = D.17392 + 3;
  D.17404 = D.17391 + D.17403;
  value.1 = (unsigned int) value;
  D.17406 = value.1 >> 24;
  D.17407 = (unsigned char) D.17406;
  *D.17404 = D.17407;
}


__attribute__((visibility ("hidden")))
mono_mb_patch_addr_s (struct MonoMethodBuilder * mb, int pos, gint8 value)
{
  unsigned char * D.17408;
  sizetype D.17409;
  unsigned char * D.17410;

  D.17408 = mb->code;
  D.17409 = (sizetype) pos;
  D.17410 = D.17408 + D.17409;
  MEM[(gint8 *)D.17410] = value;
}


__attribute__((visibility ("hidden")))
mono_mb_emit_byte (struct MonoMethodBuilder * mb, guint8 op)
{
  unsigned int D.17411;
  unsigned int D.17412;
  unsigned int D.17415;
  unsigned int D.17416;
  unsigned char * D.17417;
  long unsigned int D.17418;
  void * D.17419;
  unsigned int D.17420;
  unsigned int D.17421;
  sizetype D.17422;
  unsigned char * D.17423;

  D.17411 = mb->pos;
  D.17412 = mb->code_size;
  if (D.17411 >= D.17412) goto <D.17413>; else goto <D.17414>;
  <D.17413>:
  D.17412 = mb->code_size;
  D.17412 = mb->code_size;
  D.17415 = D.17412 >> 1;
  D.17416 = D.17412 + D.17415;
  mb->code_size = D.17416;
  D.17417 = mb->code;
  D.17412 = mb->code_size;
  D.17418 = (long unsigned int) D.17412;
  D.17419 = monoeg_realloc (D.17417, D.17418);
  mb->code = D.17419;
  <D.17414>:
  D.17417 = mb->code;
  D.17411 = mb->pos;
  D.17420 = D.17411;
  D.17421 = D.17420 + 1;
  mb->pos = D.17421;
  D.17422 = (sizetype) D.17420;
  D.17423 = D.17417 + D.17422;
  *D.17423 = op;
}


__attribute__((visibility ("hidden")))
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.17424>; else goto <D.17425>;
  <D.17424>:
  mono_mb_emit_icon (mb, offset);
  mono_mb_emit_byte (mb, 88);
  <D.17425>:
}


__attribute__((visibility ("hidden")))
mono_mb_emit_i4 (struct MonoMethodBuilder * mb, gint32 data)
{
  unsigned int D.17426;
  unsigned int D.17427;
  unsigned int D.17428;
  unsigned int D.17431;
  unsigned int D.17432;
  unsigned char * D.17433;
  long unsigned int D.17434;
  void * D.17435;
  int D.17436;

  D.17426 = mb->pos;
  D.17427 = D.17426 + 4;
  D.17428 = mb->code_size;
  if (D.17427 >= D.17428) goto <D.17429>; else goto <D.17430>;
  <D.17429>:
  D.17428 = mb->code_size;
  D.17428 = mb->code_size;
  D.17431 = D.17428 >> 1;
  D.17432 = D.17428 + D.17431;
  mb->code_size = D.17432;
  D.17433 = mb->code;
  D.17428 = mb->code_size;
  D.17434 = (long unsigned int) D.17428;
  D.17435 = monoeg_realloc (D.17433, D.17434);
  mb->code = D.17435;
  <D.17430>:
  D.17426 = mb->pos;
  D.17436 = (int) D.17426;
  mono_mb_patch_addr (mb, D.17436, data);
  D.17426 = mb->pos;
  D.17427 = D.17426 + 4;
  mb->pos = D.17427;
}


__attribute__((visibility ("hidden")))
mono_mb_emit_i2 (struct MonoMethodBuilder * mb, gint16 data)
{
  unsigned int D.17437;
  unsigned int D.17438;
  unsigned int D.17439;
  unsigned int D.17442;
  unsigned int D.17443;
  unsigned char * D.17444;
  long unsigned int D.17445;
  void * D.17446;
  sizetype D.17447;
  unsigned char * D.17448;
  unsigned char D.17449;
  unsigned int D.17450;
  sizetype D.17451;
  unsigned char * D.17452;
  short int D.17453;
  unsigned char D.17454;

  D.17437 = mb->pos;
  D.17438 = D.17437 + 2;
  D.17439 = mb->code_size;
  if (D.17438 >= D.17439) goto <D.17440>; else goto <D.17441>;
  <D.17440>:
  D.17439 = mb->code_size;
  D.17439 = mb->code_size;
  D.17442 = D.17439 >> 1;
  D.17443 = D.17439 + D.17442;
  mb->code_size = D.17443;
  D.17444 = mb->code;
  D.17439 = mb->code_size;
  D.17445 = (long unsigned int) D.17439;
  D.17446 = monoeg_realloc (D.17444, D.17445);
  mb->code = D.17446;
  <D.17441>:
  D.17444 = mb->code;
  D.17437 = mb->pos;
  D.17447 = (sizetype) D.17437;
  D.17448 = D.17444 + D.17447;
  D.17449 = (unsigned char) data;
  *D.17448 = D.17449;
  D.17444 = mb->code;
  D.17437 = mb->pos;
  D.17450 = D.17437 + 1;
  D.17451 = (sizetype) D.17450;
  D.17452 = D.17444 + D.17451;
  D.17453 = data >> 8;
  D.17454 = (unsigned char) D.17453;
  *D.17452 = D.17454;
  D.17437 = mb->pos;
  D.17438 = D.17437 + 2;
  mb->pos = D.17438;
}


__attribute__((visibility ("hidden")))
mono_mb_emit_op (struct MonoMethodBuilder * mb, guint8 op, void * data)
{
  unsigned int D.17455;
  int D.17456;

  mono_mb_emit_byte (mb, op);
  D.17455 = mono_mb_add_data (mb, data);
  D.17456 = (int) D.17455;
  mono_mb_emit_i4 (mb, D.17456);
}


__attribute__((visibility ("hidden")))
mono_mb_emit_ldstr (struct MonoMethodBuilder * mb, char * str)
{
  mono_mb_emit_op (mb, 114, str);
}


__attribute__((visibility ("hidden")))
mono_mb_emit_ldarg (struct MonoMethodBuilder * mb, guint argnum)
{
  unsigned char D.17459;
  unsigned char D.17460;
  short int D.17465;

  if (argnum <= 3) goto <D.17457>; else goto <D.17458>;
  <D.17457>:
  D.17459 = (unsigned char) argnum;
  D.17460 = D.17459 + 2;
  mono_mb_emit_byte (mb, D.17460);
  goto <D.17461>;
  <D.17458>:
  if (argnum <= 255) goto <D.17462>; else goto <D.17463>;
  <D.17462>:
  mono_mb_emit_byte (mb, 14);
  D.17459 = (unsigned char) argnum;
  mono_mb_emit_byte (mb, D.17459);
  goto <D.17464>;
  <D.17463>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 9);
  D.17465 = (short int) argnum;
  mono_mb_emit_i2 (mb, D.17465);
  <D.17464>:
  <D.17461>:
}


__attribute__((visibility ("hidden")))
mono_mb_emit_ldarg_addr (struct MonoMethodBuilder * mb, guint argnum)
{
  unsigned char D.17468;
  short int D.17470;

  if (argnum <= 255) goto <D.17466>; else goto <D.17467>;
  <D.17466>:
  mono_mb_emit_byte (mb, 15);
  D.17468 = (unsigned char) argnum;
  mono_mb_emit_byte (mb, D.17468);
  goto <D.17469>;
  <D.17467>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 10);
  D.17470 = (short int) argnum;
  mono_mb_emit_i2 (mb, D.17470);
  <D.17469>:
}


__attribute__((visibility ("hidden")))
mono_mb_emit_ldloc_addr (struct MonoMethodBuilder * mb, guint locnum)
{
  unsigned char D.17473;
  short int D.17475;

  if (locnum <= 255) goto <D.17471>; else goto <D.17472>;
  <D.17471>:
  mono_mb_emit_byte (mb, 18);
  D.17473 = (unsigned char) locnum;
  mono_mb_emit_byte (mb, D.17473);
  goto <D.17474>;
  <D.17472>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 13);
  D.17475 = (short int) locnum;
  mono_mb_emit_i2 (mb, D.17475);
  <D.17474>:
}


__attribute__((visibility ("hidden")))
mono_mb_emit_ldloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.17478;
  unsigned char D.17479;
  short int D.17484;

  if (num <= 3) goto <D.17476>; else goto <D.17477>;
  <D.17476>:
  D.17478 = (unsigned char) num;
  D.17479 = D.17478 + 6;
  mono_mb_emit_byte (mb, D.17479);
  goto <D.17480>;
  <D.17477>:
  if (num <= 255) goto <D.17481>; else goto <D.17482>;
  <D.17481>:
  mono_mb_emit_byte (mb, 17);
  D.17478 = (unsigned char) num;
  mono_mb_emit_byte (mb, D.17478);
  goto <D.17483>;
  <D.17482>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 12);
  D.17484 = (short int) num;
  mono_mb_emit_i2 (mb, D.17484);
  <D.17483>:
  <D.17480>:
}


__attribute__((visibility ("hidden")))
mono_mb_emit_stloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.17487;
  unsigned char D.17488;
  short int D.17493;

  if (num <= 3) goto <D.17485>; else goto <D.17486>;
  <D.17485>:
  D.17487 = (unsigned char) num;
  D.17488 = D.17487 + 10;
  mono_mb_emit_byte (mb, D.17488);
  goto <D.17489>;
  <D.17486>:
  if (num <= 255) goto <D.17490>; else goto <D.17491>;
  <D.17490>:
  mono_mb_emit_byte (mb, 19);
  D.17487 = (unsigned char) num;
  mono_mb_emit_byte (mb, D.17487);
  goto <D.17492>;
  <D.17491>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 14);
  D.17493 = (short int) num;
  mono_mb_emit_i2 (mb, D.17493);
  <D.17492>:
  <D.17489>:
}


__attribute__((visibility ("hidden")))
mono_mb_emit_icon (struct MonoMethodBuilder * mb, gint32 value)
{
  unsigned int value.2;
  unsigned int D.17495;
  unsigned char D.17498;
  unsigned char D.17499;
  unsigned int D.17501;

  value.2 = (unsigned int) value;
  D.17495 = value.2 + 1;
  if (D.17495 <= 8) goto <D.17496>; else goto <D.17497>;
  <D.17496>:
  D.17498 = (unsigned char) value;
  D.17499 = D.17498 + 22;
  mono_mb_emit_byte (mb, D.17499);
  goto <D.17500>;
  <D.17497>:
  value.2 = (unsigned int) value;
  D.17501 = value.2 + 128;
  if (D.17501 <= 255) goto <D.17502>; else goto <D.17503>;
  <D.17502>:
  mono_mb_emit_byte (mb, 31);
  D.17498 = (unsigned char) value;
  mono_mb_emit_byte (mb, D.17498);
  goto <D.17504>;
  <D.17503>:
  mono_mb_emit_byte (mb, 32);
  mono_mb_emit_i4 (mb, value);
  <D.17504>:
  <D.17500>:
}


__attribute__((visibility ("hidden")))
mono_mb_get_label (struct MonoMethodBuilder * mb)
{
  int D.17505;
  unsigned int D.17506;

  D.17506 = mb->pos;
  D.17505 = (int) D.17506;
  return D.17505;
}


__attribute__((visibility ("hidden")))
mono_mb_get_pos (struct MonoMethodBuilder * mb)
{
  int D.17508;
  unsigned int D.17509;

  D.17509 = mb->pos;
  D.17508 = (int) D.17509;
  return D.17508;
}


__attribute__((visibility ("hidden")))
mono_mb_emit_branch (struct MonoMethodBuilder * mb, guint8 op)
{
  guint32 D.17511;
  guint32 res;

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


__attribute__((visibility ("hidden")))
mono_mb_emit_short_branch (struct MonoMethodBuilder * mb, guint8 op)
{
  guint32 D.17513;
  guint32 res;

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


__attribute__((visibility ("hidden")))
mono_mb_emit_branch_label (struct MonoMethodBuilder * mb, guint8 op, guint32 label)
{
  unsigned int D.17515;
  unsigned int D.17516;
  unsigned int D.17517;
  int D.17518;

  mono_mb_emit_byte (mb, op);
  D.17515 = mb->pos;
  D.17516 = label - D.17515;
  D.17517 = D.17516 + 4294967292;
  D.17518 = (int) D.17517;
  mono_mb_emit_i4 (mb, D.17518);
}


__attribute__((visibility ("hidden")))
mono_mb_patch_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.3;
  unsigned int D.17520;
  unsigned int D.17521;
  unsigned int D.17522;
  int D.17523;

  pos.3 = (int) pos;
  D.17520 = mb->pos;
  D.17521 = D.17520 - pos;
  D.17522 = D.17521 + 4294967292;
  D.17523 = (int) D.17522;
  mono_mb_patch_addr (mb, pos.3, D.17523);
}


__attribute__((visibility ("hidden")))
mono_mb_patch_short_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.4;
  unsigned int D.17525;
  unsigned char D.17526;
  unsigned char D.17527;
  unsigned char D.17528;
  unsigned char D.17529;
  signed char D.17530;

  pos.4 = (int) pos;
  D.17525 = mb->pos;
  D.17526 = (unsigned char) D.17525;
  D.17527 = (unsigned char) pos;
  D.17528 = D.17526 - D.17527;
  D.17529 = D.17528 + 255;
  D.17530 = (signed char) D.17529;
  mono_mb_patch_addr_s (mb, pos.4, D.17530);
}


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


__attribute__((visibility ("hidden")))
mono_mb_emit_calli (struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig)
{
  mono_mb_emit_op (mb, 41, sig);
}


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


__attribute__((visibility ("hidden")))
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);
}


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


__attribute__((visibility ("hidden")))
mono_mb_emit_exception_full (struct MonoMethodBuilder * mb, const char * exc_nspace, const char * exc_name, const char * msg)
{
  struct MonoImage * D.17531;
  _Bool D.17532;
  long int D.17533;
  long int D.17534;
  struct MonoMethod * ctor;
  struct MonoClass * mme;

  ctor = 0B;
  D.17531 = mono_defaults.corlib;
  mme = mono_class_from_name (D.17531, exc_nspace, exc_name);
  mono_class_init (mme);
  ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
  D.17532 = ctor == 0B;
  D.17533 = (long int) D.17532;
  D.17534 = __builtin_expect (D.17533, 0);
  if (D.17534 != 0) goto <D.17535>; else goto <D.17536>;
  <D.17535>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 535, "ctor");
  <D.17536>:
  mono_mb_emit_op (mb, 115, ctor);
  if (msg != 0B) goto <D.17537>; else goto <D.17538>;
  <D.17537>:
  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.17538>:
  mono_mb_emit_byte (mb, 122);
}


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


__attribute__((visibility ("hidden")))
mono_mb_emit_add_to_local (struct MonoMethodBuilder * mb, guint16 local, gint32 incr)
{
  unsigned int D.17539;

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


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


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