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

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


mono_mb_new_base (struct MonoClass * klass, MonoWrapperType type)
{
  _Bool D.19290;
  long int D.19291;
  long int D.19292;
  unsigned char D.19295;
  <unnamed-unsigned:5> D.19296;
  unsigned int D.19297;
  void * D.19298;
  struct MonoMethodBuilder * D.19299;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * m;

  D.19290 = klass == 0B;
  D.19291 = (long int) D.19290;
  D.19292 = __builtin_expect (D.19291, 0);
  if (D.19292 != 0) goto <D.19293>; else goto <D.19294>;
  <D.19293>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 57, "klass != NULL");
  <D.19294>:
  mb = monoeg_malloc0 (52);
  m = monoeg_malloc0 (32);
  mb->method = m;
  m->klass = klass;
  m->inline_info = 1;
  D.19295 = (unsigned char) type;
  D.19296 = (<unnamed-unsigned:5>) D.19295;
  m->wrapper_type = D.19296;
  mb->code_size = 40;
  D.19297 = mb->code_size;
  D.19298 = monoeg_malloc (D.19297);
  mb->code = D.19298;
  mono_mb_add_data (mb, 0B);
  D.19299 = mb;
  return D.19299;
}


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

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


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

  if (str != 0B) goto <D.19304>; else goto <D.19305>;
  <D.19304>:
  D.19306 = __strdup (str);
  return D.19306;
  <D.19305>:
  D.19306 = 0B;
  return D.19306;
}


mono_mb_free (struct MonoMethodBuilder * mb)
{
  struct GList * D.19308;
  int D.19309;
  struct MonoMethod * D.19312;
  int D.19313;
  char * D.19316;
  unsigned char * D.19317;

  D.19308 = mb->locals_list;
  monoeg_g_list_free (D.19308);
  D.19309 = mb->dynamic;
  if (D.19309 == 0) goto <D.19310>; else goto <D.19311>;
  <D.19310>:
  D.19312 = mb->method;
  monoeg_g_free (D.19312);
  D.19313 = mb->no_dup_name;
  if (D.19313 == 0) goto <D.19314>; else goto <D.19315>;
  <D.19314>:
  D.19316 = mb->name;
  monoeg_g_free (D.19316);
  <D.19315>:
  D.19317 = mb->code;
  monoeg_g_free (D.19317);
  <D.19311>:
  monoeg_g_free (mb);
}


mono_mb_create_method (struct MonoMethodBuilder * mb, struct MonoMethodSignature * signature, int max_stack)
{
  _Bool D.19318;
  long int D.19319;
  long int D.19320;
  struct MonoMethod * D.19323;
  struct MonoClass * D.19324;
  int D.19325;
  char * D.19328;
  int D.19329;
  unsigned int D.19330;
  unsigned int D.19331;
  unsigned int D.19332;
  unsigned char * D.19333;
  void * D.19334;
  struct MonoType * D.19335;
  int D.19337;
  char * D.19341;
  unsigned int D.19342;
  void * D.19343;
  const unsigned char * D.19344;
  unsigned char D.19345;
  unsigned char D.19346;
  short unsigned int D.19349;
  short unsigned int D.19350;
  short unsigned int D.19353;
  <unnamed-unsigned:15> D.19354;
  short unsigned int D.19355;
  int D.19356;
  short unsigned int D.19357;
  <unnamed-unsigned:15> D.19358;
  struct MonoExceptionClause * D.19359;
  int D.19360;
  unsigned char D.19361;
  <unnamed-unsigned:1> D.19362;
  void * D.19363;
  unsigned int D.19364;
  unsigned char D.19367;
  unsigned char D.19368;
  int D.19371;
  unsigned int D.19372;
  unsigned int D.19373;
  void * i.0;
  int i.1;
  unsigned int i.2;
  unsigned int D.19378;
  void * * D.19379;
  void * D.19380;
  const char * * D.19381;
  short unsigned int D.19384;
  unsigned int D.19385;
  unsigned int D.19386;
  unsigned int i.3;
  unsigned int D.19388;
  char * * D.19389;
  const char * * D.19390;
  const char * D.19391;
  char * D.19392;
  int D.19393;
  struct GHashTable * D.19394;
  struct GHashTable * D.19397;
  struct MonoMethod * D.19398;
  struct MonoMethodHeader * header;
  struct MonoMethodWrapper * mw;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct GList * l;
  int i;

  D.19318 = mb == 0B;
  D.19319 = (long int) D.19318;
  D.19320 = __builtin_expect (D.19319, 0);
  if (D.19320 != 0) goto <D.19321>; else goto <D.19322>;
  <D.19321>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 132, "mb != NULL");
  <D.19322>:
  D.19323 = mb->method;
  D.19324 = D.19323->klass;
  image = D.19324->image;
  D.19325 = mb->dynamic;
  if (D.19325 != 0) goto <D.19326>; else goto <D.19327>;
  <D.19326>:
  method = mb->method;
  mw = method;
  D.19328 = mb->name;
  method->name = D.19328;
  method->dynamic = 1;
  D.19329 = mb->locals;
  D.19330 = (unsigned int) D.19329;
  D.19331 = D.19330 + 5;
  D.19332 = D.19331 * 4;
  header = monoeg_malloc0 (D.19332);
  mw->header = header;
  D.19333 = mb->code;
  header->code = D.19333;
  i = 0;
  l = mb->locals_list;
  goto <D.19124>;
  <D.19123>:
  D.19334 = l->data;
  D.19335 = mono_metadata_type_dup (0B, D.19334);
  header->locals[i] = D.19335;
  l = l->next;
  i = i + 1;
  <D.19124>:
  if (l != 0B) goto <D.19123>; else goto <D.19125>;
  <D.19125>:
  goto <D.19336>;
  <D.19327>:
  method = mono_image_alloc0 (image, 32);
  D.19323 = mb->method;
  memcpy (method, D.19323, 32);
  mw = method;
  D.19337 = mb->no_dup_name;
  if (D.19337 != 0) goto <D.19338>; else goto <D.19339>;
  <D.19338>:
  D.19328 = mb->name;
  method->name = D.19328;
  goto <D.19340>;
  <D.19339>:
  D.19328 = mb->name;
  D.19341 = mono_image_strdup (image, D.19328);
  method->name = D.19341;
  <D.19340>:
  D.19329 = mb->locals;
  D.19330 = (unsigned int) D.19329;
  D.19331 = D.19330 + 5;
  D.19332 = D.19331 * 4;
  header = mono_image_alloc0 (image, D.19332);
  mw->header = header;
  D.19342 = mb->pos;
  D.19343 = mono_image_alloc (image, D.19342);
  header->code = D.19343;
  D.19344 = header->code;
  D.19333 = mb->code;
  D.19342 = mb->pos;
  memcpy (D.19344, D.19333, D.19342);
  i = 0;
  l = mb->locals_list;
  goto <D.19127>;
  <D.19126>:
  D.19334 = l->data;
  header->locals[i] = D.19334;
  l = l->next;
  i = i + 1;
  <D.19127>:
  if (l != 0B) goto <D.19126>; else goto <D.19128>;
  <D.19128>:
  <D.19336>:
  method->signature = signature;
  D.19345 = BIT_FIELD_REF <*signature, 8, 80>;
  D.19346 = D.19345 & 64;
  if (D.19346 == 0) goto <D.19347>; else goto <D.19348>;
  <D.19347>:
  D.19349 = method->flags;
  D.19350 = D.19349 | 16;
  method->flags = D.19350;
  <D.19348>:
  if (max_stack <= 7) goto <D.19351>; else goto <D.19352>;
  <D.19351>:
  max_stack = 8;
  <D.19352>:
  D.19353 = (short unsigned int) max_stack;
  D.19354 = (<unnamed-unsigned:15>) D.19353;
  header->max_stack = D.19354;
  D.19342 = mb->pos;
  header->code_size = D.19342;
  D.19329 = mb->locals;
  D.19355 = (short unsigned int) D.19329;
  header->num_locals = D.19355;
  header->init_locals = 1;
  D.19356 = mb->num_clauses;
  D.19357 = (short unsigned int) D.19356;
  D.19358 = (<unnamed-unsigned:15>) D.19357;
  header->num_clauses = D.19358;
  D.19359 = mb->clauses;
  header->clauses = D.19359;
  D.19360 = mb->skip_visibility;
  D.19361 = (unsigned char) D.19360;
  D.19362 = (<unnamed-unsigned:1>) D.19361;
  method->skip_visibility = D.19362;
  D.19363 = mw->method_data;
  D.19364 = monoeg_g_list_length (D.19363);
  i = (int) D.19364;
  if (i != 0) goto <D.19365>; else goto <D.19366>;
  <D.19365>:
  {
    struct GList * tmp;
    void * * data;

    D.19363 = mw->method_data;
    l = monoeg_g_list_reverse (D.19363);
    D.19367 = BIT_FIELD_REF <*method, 8, 168>;
    D.19368 = D.19367 & 2;
    if (D.19368 != 0) goto <D.19369>; else goto <D.19370>;
    <D.19369>:
    D.19371 = i + 1;
    D.19372 = (unsigned int) D.19371;
    D.19373 = D.19372 * 4;
    data = monoeg_malloc (D.19373);
    goto <D.19374>;
    <D.19370>:
    D.19371 = i + 1;
    D.19372 = (unsigned int) D.19371;
    D.19373 = D.19372 * 4;
    data = mono_image_alloc (image, D.19373);
    <D.19374>:
    i.0 = (void *) i;
    *data = i.0;
    i = 1;
    tmp = l;
    goto <D.19132>;
    <D.19131>:
    i.1 = i;
    i = i.1 + 1;
    i.2 = (unsigned int) i.1;
    D.19378 = i.2 * 4;
    D.19379 = data + D.19378;
    D.19380 = tmp->data;
    *D.19379 = D.19380;
    tmp = tmp->next;
    <D.19132>:
    if (tmp != 0B) goto <D.19131>; else goto <D.19133>;
    <D.19133>:
    monoeg_g_list_free (l);
    mw->method_data = data;
  }
  <D.19366>:
  D.19381 = mb->param_names;
  if (D.19381 != 0B) goto <D.19382>; else goto <D.19383>;
  <D.19382>:
  {
    char * * param_names;

    D.19384 = signature->param_count;
    D.19385 = (unsigned int) D.19384;
    D.19386 = D.19385 * 4;
    param_names = mono_image_alloc0 (image, D.19386);
    i = 0;
    goto <D.19136>;
    <D.19135>:
    i.3 = (unsigned int) i;
    D.19388 = i.3 * 4;
    D.19389 = param_names + D.19388;
    D.19381 = mb->param_names;
    i.3 = (unsigned int) i;
    D.19388 = i.3 * 4;
    D.19390 = D.19381 + D.19388;
    D.19391 = *D.19390;
    D.19392 = mono_image_strdup (image, D.19391);
    *D.19389 = D.19392;
    i = i + 1;
    <D.19136>:
    D.19384 = signature->param_count;
    D.19393 = (int) D.19384;
    if (D.19393 > i) goto <D.19135>; else goto <D.19137>;
    <D.19137>:
    mono_image_lock (image);
    D.19394 = image->wrapper_param_names;
    if (D.19394 == 0B) goto <D.19395>; else goto <D.19396>;
    <D.19395>:
    D.19397 = monoeg_g_hash_table_new (0B, 0B);
    image->wrapper_param_names = D.19397;
    <D.19396>:
    D.19394 = image->wrapper_param_names;
    monoeg_g_hash_table_insert_replace (D.19394, method, param_names, 0);
    mono_image_unlock (image);
  }
  <D.19383>:
  D.19398 = method;
  return D.19398;
}


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

  D.19401 = __builtin_object_size (__dest, 0);
  D.19400 = __builtin___memcpy_chk (__dest, __src, __len, D.19401);
  return D.19400;
}


mono_mb_add_data (struct MonoMethodBuilder * mb, void * data)
{
  _Bool D.19403;
  long int D.19404;
  long int D.19405;
  void * D.19408;
  struct GList * D.19409;
  guint32 D.19410;
  struct MonoMethodWrapper * mw;

  D.19403 = mb == 0B;
  D.19404 = (long int) D.19403;
  D.19405 = __builtin_expect (D.19404, 0);
  if (D.19405 != 0) goto <D.19406>; else goto <D.19407>;
  <D.19406>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 254, "mb != NULL");
  <D.19407>:
  mw = mb->method;
  D.19408 = mw->method_data;
  D.19409 = monoeg_g_list_prepend (D.19408, data);
  mw->method_data = D.19409;
  D.19408 = mw->method_data;
  D.19410 = monoeg_g_list_length (D.19408);
  return D.19410;
}


mono_mb_add_local (struct MonoMethodBuilder * mb, struct MonoType * type)
{
  _Bool D.19412;
  long int D.19413;
  long int D.19414;
  _Bool D.19417;
  long int D.19418;
  long int D.19419;
  struct GList * D.19422;
  struct GList * D.19423;
  int D.19424;
  int D.19425;
  int D.19426;
  int res;

  D.19412 = mb == 0B;
  D.19413 = (long int) D.19412;
  D.19414 = __builtin_expect (D.19413, 0);
  if (D.19414 != 0) goto <D.19415>; else goto <D.19416>;
  <D.19415>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 271, "mb != NULL");
  <D.19416>:
  D.19417 = type == 0B;
  D.19418 = (long int) D.19417;
  D.19419 = __builtin_expect (D.19418, 0);
  if (D.19419 != 0) goto <D.19420>; else goto <D.19421>;
  <D.19420>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 272, "type != NULL");
  <D.19421>:
  res = mb->locals;
  D.19422 = mb->locals_list;
  D.19423 = monoeg_g_list_append (D.19422, type);
  mb->locals_list = D.19423;
  D.19424 = mb->locals;
  D.19425 = D.19424 + 1;
  mb->locals = D.19425;
  D.19426 = res;
  return D.19426;
}


mono_mb_patch_addr (struct MonoMethodBuilder * mb, int pos, int value)
{
  unsigned char * D.19428;
  sizetype pos.4;
  unsigned char * D.19430;
  unsigned char D.19431;
  sizetype D.19432;
  unsigned char * D.19433;
  int D.19434;
  unsigned char D.19435;
  sizetype D.19436;
  unsigned char * D.19437;
  int D.19438;
  unsigned char D.19439;
  sizetype D.19440;
  unsigned char * D.19441;
  unsigned int value.5;
  unsigned int D.19443;
  unsigned char D.19444;

  D.19428 = mb->code;
  pos.4 = (sizetype) pos;
  D.19430 = D.19428 + pos.4;
  D.19431 = (unsigned char) value;
  *D.19430 = D.19431;
  D.19428 = mb->code;
  pos.4 = (sizetype) pos;
  D.19432 = pos.4 + 1;
  D.19433 = D.19428 + D.19432;
  D.19434 = value >> 8;
  D.19435 = (unsigned char) D.19434;
  *D.19433 = D.19435;
  D.19428 = mb->code;
  pos.4 = (sizetype) pos;
  D.19436 = pos.4 + 2;
  D.19437 = D.19428 + D.19436;
  D.19438 = value >> 16;
  D.19439 = (unsigned char) D.19438;
  *D.19437 = D.19439;
  D.19428 = mb->code;
  pos.4 = (sizetype) pos;
  D.19440 = pos.4 + 3;
  D.19441 = D.19428 + D.19440;
  value.5 = (unsigned int) value;
  D.19443 = value.5 >> 24;
  D.19444 = (unsigned char) D.19443;
  *D.19441 = D.19444;
}


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

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


mono_mb_emit_byte (struct MonoMethodBuilder * mb, guint8 op)
{
  unsigned int D.19448;
  unsigned int D.19449;
  unsigned int D.19452;
  unsigned int D.19453;
  unsigned char * D.19454;
  void * D.19455;
  unsigned int D.19456;
  unsigned int D.19457;
  unsigned char * D.19458;

  D.19448 = mb->pos;
  D.19449 = mb->code_size;
  if (D.19448 >= D.19449) goto <D.19450>; else goto <D.19451>;
  <D.19450>:
  D.19449 = mb->code_size;
  D.19449 = mb->code_size;
  D.19452 = D.19449 >> 1;
  D.19453 = D.19449 + D.19452;
  mb->code_size = D.19453;
  D.19454 = mb->code;
  D.19449 = mb->code_size;
  D.19455 = monoeg_realloc (D.19454, D.19449);
  mb->code = D.19455;
  <D.19451>:
  D.19454 = mb->code;
  D.19448 = mb->pos;
  D.19456 = D.19448;
  D.19457 = D.19456 + 1;
  mb->pos = D.19457;
  D.19458 = D.19454 + D.19456;
  *D.19458 = 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.19459>; else goto <D.19460>;
  <D.19459>:
  mono_mb_emit_icon (mb, offset);
  mono_mb_emit_byte (mb, 88);
  <D.19460>:
}


mono_mb_emit_i4 (struct MonoMethodBuilder * mb, gint32 data)
{
  unsigned int D.19461;
  unsigned int D.19462;
  unsigned int D.19463;
  unsigned int D.19466;
  unsigned int D.19467;
  unsigned char * D.19468;
  void * D.19469;
  int D.19470;

  D.19461 = mb->pos;
  D.19462 = D.19461 + 4;
  D.19463 = mb->code_size;
  if (D.19462 >= D.19463) goto <D.19464>; else goto <D.19465>;
  <D.19464>:
  D.19463 = mb->code_size;
  D.19463 = mb->code_size;
  D.19466 = D.19463 >> 1;
  D.19467 = D.19463 + D.19466;
  mb->code_size = D.19467;
  D.19468 = mb->code;
  D.19463 = mb->code_size;
  D.19469 = monoeg_realloc (D.19468, D.19463);
  mb->code = D.19469;
  <D.19465>:
  D.19461 = mb->pos;
  D.19470 = (int) D.19461;
  mono_mb_patch_addr (mb, D.19470, data);
  D.19461 = mb->pos;
  D.19462 = D.19461 + 4;
  mb->pos = D.19462;
}


mono_mb_emit_i2 (struct MonoMethodBuilder * mb, gint16 data)
{
  unsigned int D.19471;
  unsigned int D.19472;
  unsigned int D.19473;
  unsigned int D.19476;
  unsigned int D.19477;
  unsigned char * D.19478;
  void * D.19479;
  unsigned char * D.19480;
  unsigned char D.19481;
  sizetype D.19482;
  unsigned char * D.19483;
  short int D.19484;
  unsigned char D.19485;

  D.19471 = mb->pos;
  D.19472 = D.19471 + 2;
  D.19473 = mb->code_size;
  if (D.19472 >= D.19473) goto <D.19474>; else goto <D.19475>;
  <D.19474>:
  D.19473 = mb->code_size;
  D.19473 = mb->code_size;
  D.19476 = D.19473 >> 1;
  D.19477 = D.19473 + D.19476;
  mb->code_size = D.19477;
  D.19478 = mb->code;
  D.19473 = mb->code_size;
  D.19479 = monoeg_realloc (D.19478, D.19473);
  mb->code = D.19479;
  <D.19475>:
  D.19478 = mb->code;
  D.19471 = mb->pos;
  D.19480 = D.19478 + D.19471;
  D.19481 = (unsigned char) data;
  *D.19480 = D.19481;
  D.19478 = mb->code;
  D.19471 = mb->pos;
  D.19482 = D.19471 + 1;
  D.19483 = D.19478 + D.19482;
  D.19484 = data >> 8;
  D.19485 = (unsigned char) D.19484;
  *D.19483 = D.19485;
  D.19471 = mb->pos;
  D.19472 = D.19471 + 2;
  mb->pos = D.19472;
}


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

  mono_mb_emit_byte (mb, op);
  D.19486 = mono_mb_add_data (mb, data);
  D.19487 = (int) D.19486;
  mono_mb_emit_i4 (mb, D.19487);
}


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.19490;
  unsigned char D.19491;
  short int D.19496;

  if (argnum <= 3) goto <D.19488>; else goto <D.19489>;
  <D.19488>:
  D.19490 = (unsigned char) argnum;
  D.19491 = D.19490 + 2;
  mono_mb_emit_byte (mb, D.19491);
  goto <D.19492>;
  <D.19489>:
  if (argnum <= 255) goto <D.19493>; else goto <D.19494>;
  <D.19493>:
  mono_mb_emit_byte (mb, 14);
  D.19490 = (unsigned char) argnum;
  mono_mb_emit_byte (mb, D.19490);
  goto <D.19495>;
  <D.19494>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 9);
  D.19496 = (short int) argnum;
  mono_mb_emit_i2 (mb, D.19496);
  <D.19495>:
  <D.19492>:
}


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

  if (argnum <= 255) goto <D.19497>; else goto <D.19498>;
  <D.19497>:
  mono_mb_emit_byte (mb, 15);
  D.19499 = (unsigned char) argnum;
  mono_mb_emit_byte (mb, D.19499);
  goto <D.19500>;
  <D.19498>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 10);
  D.19501 = (short int) argnum;
  mono_mb_emit_i2 (mb, D.19501);
  <D.19500>:
}


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

  if (locnum <= 255) goto <D.19502>; else goto <D.19503>;
  <D.19502>:
  mono_mb_emit_byte (mb, 18);
  D.19504 = (unsigned char) locnum;
  mono_mb_emit_byte (mb, D.19504);
  goto <D.19505>;
  <D.19503>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 13);
  D.19506 = (short int) locnum;
  mono_mb_emit_i2 (mb, D.19506);
  <D.19505>:
}


mono_mb_emit_ldloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.19509;
  unsigned char D.19510;
  short int D.19515;

  if (num <= 3) goto <D.19507>; else goto <D.19508>;
  <D.19507>:
  D.19509 = (unsigned char) num;
  D.19510 = D.19509 + 6;
  mono_mb_emit_byte (mb, D.19510);
  goto <D.19511>;
  <D.19508>:
  if (num <= 255) goto <D.19512>; else goto <D.19513>;
  <D.19512>:
  mono_mb_emit_byte (mb, 17);
  D.19509 = (unsigned char) num;
  mono_mb_emit_byte (mb, D.19509);
  goto <D.19514>;
  <D.19513>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 12);
  D.19515 = (short int) num;
  mono_mb_emit_i2 (mb, D.19515);
  <D.19514>:
  <D.19511>:
}


mono_mb_emit_stloc (struct MonoMethodBuilder * mb, guint num)
{
  unsigned char D.19518;
  unsigned char D.19519;
  short int D.19524;

  if (num <= 3) goto <D.19516>; else goto <D.19517>;
  <D.19516>:
  D.19518 = (unsigned char) num;
  D.19519 = D.19518 + 10;
  mono_mb_emit_byte (mb, D.19519);
  goto <D.19520>;
  <D.19517>:
  if (num <= 255) goto <D.19521>; else goto <D.19522>;
  <D.19521>:
  mono_mb_emit_byte (mb, 19);
  D.19518 = (unsigned char) num;
  mono_mb_emit_byte (mb, D.19518);
  goto <D.19523>;
  <D.19522>:
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 14);
  D.19524 = (short int) num;
  mono_mb_emit_i2 (mb, D.19524);
  <D.19523>:
  <D.19520>:
}


mono_mb_emit_icon (struct MonoMethodBuilder * mb, gint32 value)
{
  unsigned int value.7;
  unsigned int D.19526;
  unsigned char D.19529;
  unsigned char D.19530;
  unsigned int D.19532;

  value.7 = (unsigned int) value;
  D.19526 = value.7 + 1;
  if (D.19526 <= 8) goto <D.19527>; else goto <D.19528>;
  <D.19527>:
  D.19529 = (unsigned char) value;
  D.19530 = D.19529 + 22;
  mono_mb_emit_byte (mb, D.19530);
  goto <D.19531>;
  <D.19528>:
  value.7 = (unsigned int) value;
  D.19532 = value.7 + 128;
  if (D.19532 <= 255) goto <D.19533>; else goto <D.19534>;
  <D.19533>:
  mono_mb_emit_byte (mb, 31);
  D.19529 = (unsigned char) value;
  mono_mb_emit_byte (mb, D.19529);
  goto <D.19535>;
  <D.19534>:
  mono_mb_emit_byte (mb, 32);
  mono_mb_emit_i4 (mb, value);
  <D.19535>:
  <D.19531>:
}


mono_mb_get_label (struct MonoMethodBuilder * mb)
{
  int D.19536;
  unsigned int D.19537;

  D.19537 = mb->pos;
  D.19536 = (int) D.19537;
  return D.19536;
}


mono_mb_get_pos (struct MonoMethodBuilder * mb)
{
  int D.19539;
  unsigned int D.19540;

  D.19540 = mb->pos;
  D.19539 = (int) D.19540;
  return D.19539;
}


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

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


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

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


mono_mb_emit_branch_label (struct MonoMethodBuilder * mb, guint8 op, guint32 label)
{
  unsigned int D.19546;
  unsigned int D.19547;
  unsigned int D.19548;
  int D.19549;

  mono_mb_emit_byte (mb, op);
  D.19546 = mb->pos;
  D.19547 = label - D.19546;
  D.19548 = D.19547 + 4294967292;
  D.19549 = (int) D.19548;
  mono_mb_emit_i4 (mb, D.19549);
}


mono_mb_patch_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.8;
  unsigned int D.19551;
  unsigned int D.19552;
  unsigned int D.19553;
  int D.19554;

  pos.8 = (int) pos;
  D.19551 = mb->pos;
  D.19552 = D.19551 - pos;
  D.19553 = D.19552 + 4294967292;
  D.19554 = (int) D.19553;
  mono_mb_patch_addr (mb, pos.8, D.19554);
}


mono_mb_patch_short_branch (struct MonoMethodBuilder * mb, guint32 pos)
{
  int pos.9;
  unsigned int D.19556;
  unsigned char D.19557;
  unsigned char D.19558;
  unsigned char D.19559;
  unsigned char D.19560;
  signed char D.19561;

  pos.9 = (int) pos;
  D.19556 = mb->pos;
  D.19557 = (unsigned char) D.19556;
  D.19558 = (unsigned char) pos;
  D.19559 = D.19557 - D.19558;
  D.19560 = D.19559 + 255;
  D.19561 = (signed char) D.19560;
  mono_mb_patch_addr_s (mb, pos.9, D.19561);
}


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.19562;
  _Bool D.19563;
  long int D.19564;
  long int D.19565;
  struct MonoMethod * ctor;
  struct MonoClass * mme;

  ctor = 0B;
  D.19562 = mono_defaults.corlib;
  mme = mono_class_from_name (D.19562, exc_nspace, exc_name);
  mono_class_init (mme);
  ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
  D.19563 = ctor == 0B;
  D.19564 = (long int) D.19563;
  D.19565 = __builtin_expect (D.19564, 0);
  if (D.19565 != 0) goto <D.19566>; else goto <D.19567>;
  <D.19566>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-builder.c", 535, "ctor");
  <D.19567>:
  mono_mb_emit_op (mb, 115, ctor);
  if (msg != 0B) goto <D.19568>; else goto <D.19569>;
  <D.19568>:
  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.19569>:
  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.19570;

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


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