mono_parse_default_optimizations (const char * p)
{
  int D.24189;
  guint32 opt;

  opt = parse_optimizations (p);
  D.24189 = (int) opt;
  return D.24189;
}


parse_optimizations (const char * p)
{
  unsigned int D.24191;
  unsigned int exclude.0;
  unsigned int D.24193;
  guint32 D.24196;
  char D.24197;
  short int D.24201;
  sizetype D.24202;
  unsigned int D.24203;
  unsigned int len.1;
  int D.24205;
  int D.24210;
  int D.24211;
  unsigned int D.24212;
  unsigned int D.24214;
  sizetype len.2;
  void (*<T3c4a>) (const char *) D.24220;
  const char * p.3;
  char D.24225;
  unsigned int i.4;
  const char * D.24228;
  int D.24232;
  unsigned int D.24238;
  struct _IO_FILE * stderr.5;
  guint32 opt;
  guint32 exclude;
  const char * n;
  int i;
  int invert;
  int len;

  try
    {
      opt = 370223615;
      exclude = 0;
      mono_hwcap_init ();
      D.24191 = mono_arch_cpu_optimizations (&exclude);
      opt = D.24191 | opt;
      exclude.0 = exclude;
      D.24193 = ~exclude.0;
      opt = D.24193 & opt;
      if (p == 0B) goto <D.24194>; else goto <D.24195>;
      <D.24194>:
      D.24196 = opt;
      return D.24196;
      <D.24195>:
      goto <D.23092>;
      <D.23091>:
      D.24197 = *p;
      if (D.24197 == 45) goto <D.24198>; else goto <D.24199>;
      <D.24198>:
      p = p + 1;
      invert = 1;
      goto <D.24200>;
      <D.24199>:
      invert = 0;
      <D.24200>:
      i = 0;
      goto <D.23081>;
      <D.23080>:
      D.24201 = opt_names[i];
      D.24202 = (sizetype) D.24201;
      n = &opstr + D.24202;
      D.24203 = strlen (n);
      len = (int) D.24203;
      len.1 = (unsigned int) len;
      D.24205 = strncmp (p, n, len.1);
      if (D.24205 == 0) goto <D.24206>; else goto <D.24207>;
      <D.24206>:
      if (invert != 0) goto <D.24208>; else goto <D.24209>;
      <D.24208>:
      D.24210 = 1 << i;
      D.24211 = ~D.24210;
      D.24212 = (unsigned int) D.24211;
      opt = D.24212 & opt;
      goto <D.24213>;
      <D.24209>:
      D.24210 = 1 << i;
      D.24214 = (unsigned int) D.24210;
      opt = D.24214 | opt;
      <D.24213>:
      len.2 = (sizetype) len;
      p = p + len.2;
      D.24197 = *p;
      if (D.24197 == 44) goto <D.24216>; else goto <D.24217>;
      <D.24216>:
      p = p + 1;
      goto <D.23076>;
      <D.24217>:
      D.24197 = *p;
      if (D.24197 == 61) goto <D.24218>; else goto <D.24219>;
      <D.24218>:
      p = p + 1;
      D.24220 = opt_funcs[i];
      if (D.24220 != 0B) goto <D.24221>; else goto <D.24222>;
      <D.24221>:
      D.24220 = opt_funcs[i];
      D.24220 (p);
      <D.24222>:
      goto <D.23078>;
      <D.23077>:
      <D.23078>:
      D.24197 = *p;
      if (D.24197 != 0) goto <D.24223>; else goto <D.23079>;
      <D.24223>:
      p.3 = p;
      p = p.3 + 1;
      D.24225 = *p.3;
      if (D.24225 != 44) goto <D.23077>; else goto <D.23079>;
      <D.23079>:
      goto <D.23076>;
      <D.24219>:
      goto <D.23076>;
      <D.24207>:
      i = i + 1;
      <D.23081>:
      i.4 = (unsigned int) i;
      if (i.4 <= 28) goto <D.24227>; else goto <D.23076>;
      <D.24227>:
      D.24201 = opt_names[i];
      D.24202 = (sizetype) D.24201;
      D.24228 = &opstr + D.24202;
      if (D.24228 != 0B) goto <D.23080>; else goto <D.23076>;
      <D.23076>:
      if (i == 29) goto <D.24229>; else goto <D.24231>;
      <D.24231>:
      D.24201 = opt_names[i];
      D.24202 = (sizetype) D.24201;
      D.24228 = &opstr + D.24202;
      if (D.24228 == 0B) goto <D.24229>; else goto <D.24230>;
      <D.24229>:
      D.24232 = strncmp (p, "all", 3);
      if (D.24232 == 0) goto <D.24233>; else goto <D.24234>;
      <D.24233>:
      if (invert != 0) goto <D.24235>; else goto <D.24236>;
      <D.24235>:
      opt = 0;
      goto <D.24237>;
      <D.24236>:
      exclude.0 = exclude;
      D.24238 = exclude.0 | 151126528;
      opt = ~D.24238;
      <D.24237>:
      p = p + 3;
      D.24197 = *p;
      if (D.24197 == 44) goto <D.24239>; else goto <D.24240>;
      <D.24239>:
      p = p + 1;
      <D.24240>:
      goto <D.24241>;
      <D.24234>:
      stderr.5 = stderr;
      fprintf (stderr.5, "Invalid optimization name `%s\'\n", p);
      exit (1);
      <D.24241>:
      <D.24230>:
      <D.23092>:
      D.24197 = *p;
      if (D.24197 != 0) goto <D.23091>; else goto <D.23093>;
      <D.23093>:
      D.24196 = opt;
      return D.24196;
    }
  finally
    {
      exclude = {CLOBBER};
    }
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.24245;

  D.24245 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.24245;
}


mono_jit_exec (struct MonoDomain * domain, struct MonoAssembly * assembly, int argc, char * * argv)
{
  const char * D.24249;
  int D.24250;
  struct MonoImage * image;
  struct MonoMethod * method;
  guint32 entry;

  image = mono_assembly_get_image (assembly);
  entry = mono_image_get_entry_point (image);
  if (entry == 0) goto <D.24247>; else goto <D.24248>;
  <D.24247>:
  D.24249 = mono_image_get_filename (image);
  monoeg_g_print ("Assembly \'%s\' doesn\'t have an entry point.\n", D.24249);
  mono_environment_exitcode_set (1);
  D.24250 = 1;
  return D.24250;
  <D.24248>:
  method = mono_get_method (image, entry, 0B);
  if (method == 0B) goto <D.24251>; else goto <D.24252>;
  <D.24251>:
  monoeg_g_print ("The entry point method could not be loaded\n");
  mono_environment_exitcode_set (1);
  D.24250 = 1;
  return D.24250;
  <D.24252>:
  D.24250 = mono_runtime_run_main (method, argc, argv, 0B);
  return D.24250;
}


mono_jit_parse_options (int argc, char * * argv)
{
  unsigned int i.6;
  unsigned int D.24255;
  char * * D.24256;
  char * D.24257;
  char D.24258;
  int D.24260;
  char * D.24263;
  int D.23406;
  int iftmp.7;
  int D.23405;
  const char[19] * D.24268;
  unsigned char D.24269;
  int D.24270;
  unsigned char D.24271;
  int D.24272;
  _Bool D.24273;
  _Bool D.24274;
  _Bool D.24275;
  const unsigned char * D.24278;
  unsigned char D.24279;
  int D.24280;
  const unsigned char * D.24281;
  unsigned char D.24282;
  int D.24283;
  _Bool D.24284;
  _Bool D.24285;
  const unsigned char * D.24288;
  unsigned char D.24289;
  int D.24290;
  const unsigned char * D.24291;
  unsigned char D.24292;
  int D.24293;
  _Bool D.24294;
  _Bool D.24295;
  const unsigned char * D.24298;
  unsigned char D.24299;
  int D.24300;
  const unsigned char * D.24301;
  unsigned char D.24302;
  int D.24303;
  int D.24308;
  const char * D.24311;
  int D.24313;
  const char * D.24316;
  int D.23436;
  int iftmp.8;
  int D.23435;
  const char[8] * D.24321;
  unsigned char D.24322;
  int D.24323;
  unsigned char D.24324;
  int D.24325;
  _Bool D.24326;
  _Bool D.24327;
  _Bool D.24328;
  const unsigned char * D.24331;
  unsigned char D.24332;
  int D.24333;
  const unsigned char * D.24334;
  unsigned char D.24335;
  int D.24336;
  _Bool D.24337;
  _Bool D.24338;
  const unsigned char * D.24341;
  unsigned char D.24342;
  int D.24343;
  const unsigned char * D.24344;
  unsigned char D.24345;
  int D.24346;
  _Bool D.24347;
  _Bool D.24348;
  const unsigned char * D.24351;
  unsigned char D.24352;
  int D.24353;
  const unsigned char * D.24354;
  unsigned char D.24355;
  int D.24356;
  int D.24361;
  int D.23454;
  int iftmp.9;
  int D.23453;
  const char[10] * D.24371;
  unsigned char D.24372;
  int D.24373;
  unsigned char D.24374;
  int D.24375;
  _Bool D.24376;
  _Bool D.24377;
  _Bool D.24378;
  const unsigned char * D.24381;
  unsigned char D.24382;
  int D.24383;
  const unsigned char * D.24384;
  unsigned char D.24385;
  int D.24386;
  _Bool D.24387;
  _Bool D.24388;
  const unsigned char * D.24391;
  unsigned char D.24392;
  int D.24393;
  const unsigned char * D.24394;
  unsigned char D.24395;
  int D.24396;
  _Bool D.24397;
  _Bool D.24398;
  const unsigned char * D.24401;
  unsigned char D.24402;
  int D.24403;
  const unsigned char * D.24404;
  unsigned char D.24405;
  int D.24406;
  int D.23463;
  int iftmp.10;
  int D.23462;
  const char[3] * D.24412;
  unsigned char D.24413;
  int D.24414;
  unsigned char D.24415;
  int D.24416;
  _Bool D.24417;
  _Bool D.24418;
  _Bool D.24419;
  const unsigned char * D.24422;
  unsigned char D.24423;
  int D.24424;
  const unsigned char * D.24425;
  unsigned char D.24426;
  int D.24427;
  _Bool D.24428;
  _Bool D.24429;
  const unsigned char * D.24432;
  unsigned char D.24433;
  int D.24434;
  const unsigned char * D.24435;
  unsigned char D.24436;
  int D.24437;
  _Bool D.24438;
  _Bool D.24439;
  const unsigned char * D.24442;
  unsigned char D.24443;
  int D.24444;
  const unsigned char * D.24445;
  unsigned char D.24446;
  int D.24447;
  int D.23472;
  int iftmp.11;
  int D.23471;
  const char[12] * D.24452;
  unsigned char D.24453;
  int D.24454;
  unsigned char D.24455;
  int D.24456;
  _Bool D.24457;
  _Bool D.24458;
  _Bool D.24459;
  const unsigned char * D.24462;
  unsigned char D.24463;
  int D.24464;
  const unsigned char * D.24465;
  unsigned char D.24466;
  int D.24467;
  _Bool D.24468;
  _Bool D.24469;
  const unsigned char * D.24472;
  unsigned char D.24473;
  int D.24474;
  const unsigned char * D.24475;
  unsigned char D.24476;
  int D.24477;
  _Bool D.24478;
  _Bool D.24479;
  const unsigned char * D.24482;
  unsigned char D.24483;
  int D.24484;
  const unsigned char * D.24485;
  unsigned char D.24486;
  int D.24487;
  int D.23482;
  int iftmp.12;
  int D.23481;
  const char[8] * D.24495;
  unsigned char D.24496;
  int D.24497;
  unsigned char D.24498;
  int D.24499;
  _Bool D.24500;
  _Bool D.24501;
  _Bool D.24502;
  const unsigned char * D.24505;
  unsigned char D.24506;
  int D.24507;
  const unsigned char * D.24508;
  unsigned char D.24509;
  int D.24510;
  _Bool D.24511;
  _Bool D.24512;
  const unsigned char * D.24515;
  unsigned char D.24516;
  int D.24517;
  const unsigned char * D.24518;
  unsigned char D.24519;
  int D.24520;
  _Bool D.24521;
  _Bool D.24522;
  const unsigned char * D.24525;
  unsigned char D.24526;
  int D.24527;
  const unsigned char * D.24528;
  unsigned char D.24529;
  int D.24530;
  int D.23491;
  int iftmp.13;
  int D.23490;
  const char[8] * D.24538;
  unsigned char D.24539;
  int D.24540;
  unsigned char D.24541;
  int D.24542;
  _Bool D.24543;
  _Bool D.24544;
  _Bool D.24545;
  const unsigned char * D.24548;
  unsigned char D.24549;
  int D.24550;
  const unsigned char * D.24551;
  unsigned char D.24552;
  int D.24553;
  _Bool D.24554;
  _Bool D.24555;
  const unsigned char * D.24558;
  unsigned char D.24559;
  int D.24560;
  const unsigned char * D.24561;
  unsigned char D.24562;
  int D.24563;
  _Bool D.24564;
  _Bool D.24565;
  const unsigned char * D.24568;
  unsigned char D.24569;
  int D.24570;
  const unsigned char * D.24571;
  unsigned char D.24572;
  int D.24573;
  int D.24577;
  struct _IO_FILE * stderr.14;
  int D.24581;
  int D.23500;
  int iftmp.15;
  int D.23499;
  const char[7] * D.24588;
  unsigned char D.24589;
  int D.24590;
  unsigned char D.24591;
  int D.24592;
  _Bool D.24593;
  _Bool D.24594;
  _Bool D.24595;
  const unsigned char * D.24598;
  unsigned char D.24599;
  int D.24600;
  const unsigned char * D.24601;
  unsigned char D.24602;
  int D.24603;
  _Bool D.24604;
  _Bool D.24605;
  const unsigned char * D.24608;
  unsigned char D.24609;
  int D.24610;
  const unsigned char * D.24611;
  unsigned char D.24612;
  int D.24613;
  _Bool D.24614;
  _Bool D.24615;
  const unsigned char * D.24618;
  unsigned char D.24619;
  int D.24620;
  const unsigned char * D.24621;
  unsigned char D.24622;
  int D.24623;
  struct MonoTraceSpec * mono_jit_trace_calls.16;
  struct MonoTraceSpec * mono_jit_trace_calls.17;
  unsigned int mini_verbose.18;
  int i;
  char * trace_options;
  int mini_verbose;

  trace_options = 0B;
  mini_verbose = 0;
  i = 0;
  goto <D.23502>;
  <D.23501>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  D.24258 = *D.24257;
  if (D.24258 != 45) goto <D.23387>; else goto <D.24259>;
  <D.24259>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  D.24260 = strncmp (D.24257, "--debugger-agent=", 17);
  if (D.24260 == 0) goto <D.24261>; else goto <D.24262>;
  <D.24261>:
  {
    struct MonoDebugOptions * opt;

    opt = mini_get_debug_options ();
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    D.24263 = D.24257 + 17;
    mono_debugger_agent_parse_options (D.24263);
    opt->mdb_optimizations = 1;
    enable_debugging = 1;
  }
  goto <D.24264>;
  <D.24262>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 18;
    if (__s2_len <= 3) goto <D.24266>; else goto <D.24267>;
    <D.24266>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24268 = "--soft-breakpoints";
      D.24269 = MEM[(const unsigned char *)D.24268];
      D.24270 = (int) D.24269;
      D.24271 = *__s2;
      D.24272 = (int) D.24271;
      __result = D.24270 - D.24272;
      {
        D.24273 = __s2_len != 0;
        D.24274 = __result == 0;
        D.24275 = D.24273 & D.24274;
        if (D.24275 != 0) goto <D.24276>; else goto <D.24277>;
        <D.24276>:
        D.24278 = &MEM[(void *)"--soft-breakpoints" + 1B];
        D.24279 = *D.24278;
        D.24280 = (int) D.24279;
        D.24281 = __s2 + 1;
        D.24282 = *D.24281;
        D.24283 = (int) D.24282;
        __result = D.24280 - D.24283;
        D.24284 = __s2_len > 1;
        D.24274 = __result == 0;
        D.24285 = D.24284 & D.24274;
        if (D.24285 != 0) goto <D.24286>; else goto <D.24287>;
        <D.24286>:
        D.24288 = &MEM[(void *)"--soft-breakpoints" + 2B];
        D.24289 = *D.24288;
        D.24290 = (int) D.24289;
        D.24291 = __s2 + 2;
        D.24292 = *D.24291;
        D.24293 = (int) D.24292;
        __result = D.24290 - D.24293;
        D.24294 = __s2_len > 2;
        D.24274 = __result == 0;
        D.24295 = D.24294 & D.24274;
        if (D.24295 != 0) goto <D.24296>; else goto <D.24297>;
        <D.24296>:
        D.24298 = &MEM[(void *)"--soft-breakpoints" + 3B];
        D.24299 = *D.24298;
        D.24300 = (int) D.24299;
        D.24301 = __s2 + 3;
        D.24302 = *D.24301;
        D.24303 = (int) D.24302;
        __result = D.24300 - D.24303;
        <D.24297>:
        <D.24287>:
        <D.24277>:
      }
      D.23405 = __result;
    }
    iftmp.7 = -D.23405;
    goto <D.24304>;
    <D.24267>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.7 = __builtin_strcmp (D.24257, "--soft-breakpoints");
    <D.24304>:
    D.23406 = iftmp.7;
  }
  if (D.23406 == 0) goto <D.24305>; else goto <D.24306>;
  <D.24305>:
  {
    struct MonoDebugOptions * opt;

    opt = mini_get_debug_options ();
    opt->soft_breakpoints = 1;
    opt->explicit_null_checks = 1;
  }
  goto <D.24307>;
  <D.24306>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  D.24308 = strncmp (D.24257, "--optimize=", 11);
  if (D.24308 == 0) goto <D.24309>; else goto <D.24310>;
  <D.24309>:
  {
    guint32 opt;

    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    D.24311 = D.24257 + 11;
    opt = parse_optimizations (D.24311);
    mono_set_optimizations (opt);
  }
  goto <D.24312>;
  <D.24310>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  D.24313 = strncmp (D.24257, "-O=", 3);
  if (D.24313 == 0) goto <D.24314>; else goto <D.24315>;
  <D.24314>:
  {
    guint32 opt;

    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    D.24316 = D.24257 + 3;
    opt = parse_optimizations (D.24316);
    mono_set_optimizations (opt);
  }
  goto <D.24317>;
  <D.24315>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.24319>; else goto <D.24320>;
    <D.24319>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24321 = "--trace";
      D.24322 = MEM[(const unsigned char *)D.24321];
      D.24323 = (int) D.24322;
      D.24324 = *__s2;
      D.24325 = (int) D.24324;
      __result = D.24323 - D.24325;
      {
        D.24326 = __s2_len != 0;
        D.24327 = __result == 0;
        D.24328 = D.24326 & D.24327;
        if (D.24328 != 0) goto <D.24329>; else goto <D.24330>;
        <D.24329>:
        D.24331 = &MEM[(void *)"--trace" + 1B];
        D.24332 = *D.24331;
        D.24333 = (int) D.24332;
        D.24334 = __s2 + 1;
        D.24335 = *D.24334;
        D.24336 = (int) D.24335;
        __result = D.24333 - D.24336;
        D.24337 = __s2_len > 1;
        D.24327 = __result == 0;
        D.24338 = D.24337 & D.24327;
        if (D.24338 != 0) goto <D.24339>; else goto <D.24340>;
        <D.24339>:
        D.24341 = &MEM[(void *)"--trace" + 2B];
        D.24342 = *D.24341;
        D.24343 = (int) D.24342;
        D.24344 = __s2 + 2;
        D.24345 = *D.24344;
        D.24346 = (int) D.24345;
        __result = D.24343 - D.24346;
        D.24347 = __s2_len > 2;
        D.24327 = __result == 0;
        D.24348 = D.24347 & D.24327;
        if (D.24348 != 0) goto <D.24349>; else goto <D.24350>;
        <D.24349>:
        D.24351 = &MEM[(void *)"--trace" + 3B];
        D.24352 = *D.24351;
        D.24353 = (int) D.24352;
        D.24354 = __s2 + 3;
        D.24355 = *D.24354;
        D.24356 = (int) D.24355;
        __result = D.24353 - D.24356;
        <D.24350>:
        <D.24340>:
        <D.24330>:
      }
      D.23435 = __result;
    }
    iftmp.8 = -D.23435;
    goto <D.24357>;
    <D.24320>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.8 = __builtin_strcmp (D.24257, "--trace");
    <D.24357>:
    D.23436 = iftmp.8;
  }
  if (D.23436 == 0) goto <D.24358>; else goto <D.24359>;
  <D.24358>:
  trace_options = "";
  goto <D.24360>;
  <D.24359>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  D.24361 = strncmp (D.24257, "--trace=", 8);
  if (D.24361 == 0) goto <D.24362>; else goto <D.24363>;
  <D.24362>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  trace_options = D.24257 + 8;
  goto <D.24364>;
  <D.24363>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.24369>; else goto <D.24370>;
    <D.24369>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24371 = "--verbose";
      D.24372 = MEM[(const unsigned char *)D.24371];
      D.24373 = (int) D.24372;
      D.24374 = *__s2;
      D.24375 = (int) D.24374;
      __result = D.24373 - D.24375;
      {
        D.24376 = __s2_len != 0;
        D.24377 = __result == 0;
        D.24378 = D.24376 & D.24377;
        if (D.24378 != 0) goto <D.24379>; else goto <D.24380>;
        <D.24379>:
        D.24381 = &MEM[(void *)"--verbose" + 1B];
        D.24382 = *D.24381;
        D.24383 = (int) D.24382;
        D.24384 = __s2 + 1;
        D.24385 = *D.24384;
        D.24386 = (int) D.24385;
        __result = D.24383 - D.24386;
        D.24387 = __s2_len > 1;
        D.24377 = __result == 0;
        D.24388 = D.24387 & D.24377;
        if (D.24388 != 0) goto <D.24389>; else goto <D.24390>;
        <D.24389>:
        D.24391 = &MEM[(void *)"--verbose" + 2B];
        D.24392 = *D.24391;
        D.24393 = (int) D.24392;
        D.24394 = __s2 + 2;
        D.24395 = *D.24394;
        D.24396 = (int) D.24395;
        __result = D.24393 - D.24396;
        D.24397 = __s2_len > 2;
        D.24377 = __result == 0;
        D.24398 = D.24397 & D.24377;
        if (D.24398 != 0) goto <D.24399>; else goto <D.24400>;
        <D.24399>:
        D.24401 = &MEM[(void *)"--verbose" + 3B];
        D.24402 = *D.24401;
        D.24403 = (int) D.24402;
        D.24404 = __s2 + 3;
        D.24405 = *D.24404;
        D.24406 = (int) D.24405;
        __result = D.24403 - D.24406;
        <D.24400>:
        <D.24390>:
        <D.24380>:
      }
      D.23453 = __result;
    }
    iftmp.9 = -D.23453;
    goto <D.24407>;
    <D.24370>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.9 = __builtin_strcmp (D.24257, "--verbose");
    <D.24407>:
    D.23454 = iftmp.9;
  }
  if (D.23454 == 0) goto <D.24365>; else goto <D.24408>;
  <D.24408>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 2;
    if (__s2_len <= 3) goto <D.24410>; else goto <D.24411>;
    <D.24410>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24412 = "-v";
      D.24413 = MEM[(const unsigned char *)D.24412];
      D.24414 = (int) D.24413;
      D.24415 = *__s2;
      D.24416 = (int) D.24415;
      __result = D.24414 - D.24416;
      {
        D.24417 = __s2_len != 0;
        D.24418 = __result == 0;
        D.24419 = D.24417 & D.24418;
        if (D.24419 != 0) goto <D.24420>; else goto <D.24421>;
        <D.24420>:
        D.24422 = &MEM[(void *)"-v" + 1B];
        D.24423 = *D.24422;
        D.24424 = (int) D.24423;
        D.24425 = __s2 + 1;
        D.24426 = *D.24425;
        D.24427 = (int) D.24426;
        __result = D.24424 - D.24427;
        D.24428 = __s2_len > 1;
        D.24418 = __result == 0;
        D.24429 = D.24428 & D.24418;
        if (D.24429 != 0) goto <D.24430>; else goto <D.24431>;
        <D.24430>:
        D.24432 = &MEM[(void *)"-v" + 2B];
        D.24433 = *D.24432;
        D.24434 = (int) D.24433;
        D.24435 = __s2 + 2;
        D.24436 = *D.24435;
        D.24437 = (int) D.24436;
        __result = D.24434 - D.24437;
        D.24438 = __s2_len > 2;
        D.24418 = __result == 0;
        D.24439 = D.24438 & D.24418;
        if (D.24439 != 0) goto <D.24440>; else goto <D.24441>;
        <D.24440>:
        D.24442 = &MEM[(void *)"-v" + 3B];
        D.24443 = *D.24442;
        D.24444 = (int) D.24443;
        D.24445 = __s2 + 3;
        D.24446 = *D.24445;
        D.24447 = (int) D.24446;
        __result = D.24444 - D.24447;
        <D.24441>:
        <D.24431>:
        <D.24421>:
      }
      D.23462 = __result;
    }
    iftmp.10 = -D.23462;
    goto <D.24448>;
    <D.24411>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.10 = __builtin_strcmp (D.24257, "-v");
    <D.24448>:
    D.23463 = iftmp.10;
  }
  if (D.23463 == 0) goto <D.24365>; else goto <D.24366>;
  <D.24365>:
  mini_verbose = mini_verbose + 1;
  goto <D.24367>;
  <D.24366>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.24450>; else goto <D.24451>;
    <D.24450>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24452 = "--breakonex";
      D.24453 = MEM[(const unsigned char *)D.24452];
      D.24454 = (int) D.24453;
      D.24455 = *__s2;
      D.24456 = (int) D.24455;
      __result = D.24454 - D.24456;
      {
        D.24457 = __s2_len != 0;
        D.24458 = __result == 0;
        D.24459 = D.24457 & D.24458;
        if (D.24459 != 0) goto <D.24460>; else goto <D.24461>;
        <D.24460>:
        D.24462 = &MEM[(void *)"--breakonex" + 1B];
        D.24463 = *D.24462;
        D.24464 = (int) D.24463;
        D.24465 = __s2 + 1;
        D.24466 = *D.24465;
        D.24467 = (int) D.24466;
        __result = D.24464 - D.24467;
        D.24468 = __s2_len > 1;
        D.24458 = __result == 0;
        D.24469 = D.24468 & D.24458;
        if (D.24469 != 0) goto <D.24470>; else goto <D.24471>;
        <D.24470>:
        D.24472 = &MEM[(void *)"--breakonex" + 2B];
        D.24473 = *D.24472;
        D.24474 = (int) D.24473;
        D.24475 = __s2 + 2;
        D.24476 = *D.24475;
        D.24477 = (int) D.24476;
        __result = D.24474 - D.24477;
        D.24478 = __s2_len > 2;
        D.24458 = __result == 0;
        D.24479 = D.24478 & D.24458;
        if (D.24479 != 0) goto <D.24480>; else goto <D.24481>;
        <D.24480>:
        D.24482 = &MEM[(void *)"--breakonex" + 3B];
        D.24483 = *D.24482;
        D.24484 = (int) D.24483;
        D.24485 = __s2 + 3;
        D.24486 = *D.24485;
        D.24487 = (int) D.24486;
        __result = D.24484 - D.24487;
        <D.24481>:
        <D.24471>:
        <D.24461>:
      }
      D.23471 = __result;
    }
    iftmp.11 = -D.23471;
    goto <D.24488>;
    <D.24451>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.11 = __builtin_strcmp (D.24257, "--breakonex");
    <D.24488>:
    D.23472 = iftmp.11;
  }
  if (D.23472 == 0) goto <D.24489>; else goto <D.24490>;
  <D.24489>:
  {
    struct MonoDebugOptions * opt;

    opt = mini_get_debug_options ();
    opt->break_on_exc = 1;
  }
  goto <D.24491>;
  <D.24490>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.24493>; else goto <D.24494>;
    <D.24493>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24495 = "--stats";
      D.24496 = MEM[(const unsigned char *)D.24495];
      D.24497 = (int) D.24496;
      D.24498 = *__s2;
      D.24499 = (int) D.24498;
      __result = D.24497 - D.24499;
      {
        D.24500 = __s2_len != 0;
        D.24501 = __result == 0;
        D.24502 = D.24500 & D.24501;
        if (D.24502 != 0) goto <D.24503>; else goto <D.24504>;
        <D.24503>:
        D.24505 = &MEM[(void *)"--stats" + 1B];
        D.24506 = *D.24505;
        D.24507 = (int) D.24506;
        D.24508 = __s2 + 1;
        D.24509 = *D.24508;
        D.24510 = (int) D.24509;
        __result = D.24507 - D.24510;
        D.24511 = __s2_len > 1;
        D.24501 = __result == 0;
        D.24512 = D.24511 & D.24501;
        if (D.24512 != 0) goto <D.24513>; else goto <D.24514>;
        <D.24513>:
        D.24515 = &MEM[(void *)"--stats" + 2B];
        D.24516 = *D.24515;
        D.24517 = (int) D.24516;
        D.24518 = __s2 + 2;
        D.24519 = *D.24518;
        D.24520 = (int) D.24519;
        __result = D.24517 - D.24520;
        D.24521 = __s2_len > 2;
        D.24501 = __result == 0;
        D.24522 = D.24521 & D.24501;
        if (D.24522 != 0) goto <D.24523>; else goto <D.24524>;
        <D.24523>:
        D.24525 = &MEM[(void *)"--stats" + 3B];
        D.24526 = *D.24525;
        D.24527 = (int) D.24526;
        D.24528 = __s2 + 3;
        D.24529 = *D.24528;
        D.24530 = (int) D.24529;
        __result = D.24527 - D.24530;
        <D.24524>:
        <D.24514>:
        <D.24504>:
      }
      D.23481 = __result;
    }
    iftmp.12 = -D.23481;
    goto <D.24531>;
    <D.24494>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.12 = __builtin_strcmp (D.24257, "--stats");
    <D.24531>:
    D.23482 = iftmp.12;
  }
  if (D.23482 == 0) goto <D.24532>; else goto <D.24533>;
  <D.24532>:
  mono_counters_enable (-1);
  mono_stats.enabled = 1;
  mono_jit_stats.enabled = 1;
  goto <D.24534>;
  <D.24533>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.24536>; else goto <D.24537>;
    <D.24536>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24538 = "--break";
      D.24539 = MEM[(const unsigned char *)D.24538];
      D.24540 = (int) D.24539;
      D.24541 = *__s2;
      D.24542 = (int) D.24541;
      __result = D.24540 - D.24542;
      {
        D.24543 = __s2_len != 0;
        D.24544 = __result == 0;
        D.24545 = D.24543 & D.24544;
        if (D.24545 != 0) goto <D.24546>; else goto <D.24547>;
        <D.24546>:
        D.24548 = &MEM[(void *)"--break" + 1B];
        D.24549 = *D.24548;
        D.24550 = (int) D.24549;
        D.24551 = __s2 + 1;
        D.24552 = *D.24551;
        D.24553 = (int) D.24552;
        __result = D.24550 - D.24553;
        D.24554 = __s2_len > 1;
        D.24544 = __result == 0;
        D.24555 = D.24554 & D.24544;
        if (D.24555 != 0) goto <D.24556>; else goto <D.24557>;
        <D.24556>:
        D.24558 = &MEM[(void *)"--break" + 2B];
        D.24559 = *D.24558;
        D.24560 = (int) D.24559;
        D.24561 = __s2 + 2;
        D.24562 = *D.24561;
        D.24563 = (int) D.24562;
        __result = D.24560 - D.24563;
        D.24564 = __s2_len > 2;
        D.24544 = __result == 0;
        D.24565 = D.24564 & D.24544;
        if (D.24565 != 0) goto <D.24566>; else goto <D.24567>;
        <D.24566>:
        D.24568 = &MEM[(void *)"--break" + 3B];
        D.24569 = *D.24568;
        D.24570 = (int) D.24569;
        D.24571 = __s2 + 3;
        D.24572 = *D.24571;
        D.24573 = (int) D.24572;
        __result = D.24570 - D.24573;
        <D.24567>:
        <D.24557>:
        <D.24547>:
      }
      D.23490 = __result;
    }
    iftmp.13 = -D.23490;
    goto <D.24574>;
    <D.24537>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.13 = __builtin_strcmp (D.24257, "--break");
    <D.24574>:
    D.23491 = iftmp.13;
  }
  if (D.23491 == 0) goto <D.24575>; else goto <D.24576>;
  <D.24575>:
  D.24577 = i + 1;
  if (D.24577 >= argc) goto <D.24578>; else goto <D.24579>;
  <D.24578>:
  stderr.14 = stderr;
  fprintf (stderr.14, "Missing method name in --break command line option\n");
  exit (1);
  <D.24579>:
  i = i + 1;
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  D.24581 = mono_debugger_insert_breakpoint (D.24257, 0);
  if (D.24581 == 0) goto <D.24582>; else goto <D.24583>;
  <D.24582>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  stderr.14 = stderr;
  fprintf (stderr.14, "Error: invalid method name \'%s\'\n", D.24257);
  <D.24583>:
  goto <D.24584>;
  <D.24576>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.24586>; else goto <D.24587>;
    <D.24586>:
    {
      const unsigned char * __s2;
      int __result;

      i.6 = (unsigned int) i;
      D.24255 = i.6 * 4;
      D.24256 = argv + D.24255;
      __s2 = *D.24256;
      D.24588 = "--llvm";
      D.24589 = MEM[(const unsigned char *)D.24588];
      D.24590 = (int) D.24589;
      D.24591 = *__s2;
      D.24592 = (int) D.24591;
      __result = D.24590 - D.24592;
      {
        D.24593 = __s2_len != 0;
        D.24594 = __result == 0;
        D.24595 = D.24593 & D.24594;
        if (D.24595 != 0) goto <D.24596>; else goto <D.24597>;
        <D.24596>:
        D.24598 = &MEM[(void *)"--llvm" + 1B];
        D.24599 = *D.24598;
        D.24600 = (int) D.24599;
        D.24601 = __s2 + 1;
        D.24602 = *D.24601;
        D.24603 = (int) D.24602;
        __result = D.24600 - D.24603;
        D.24604 = __s2_len > 1;
        D.24594 = __result == 0;
        D.24605 = D.24604 & D.24594;
        if (D.24605 != 0) goto <D.24606>; else goto <D.24607>;
        <D.24606>:
        D.24608 = &MEM[(void *)"--llvm" + 2B];
        D.24609 = *D.24608;
        D.24610 = (int) D.24609;
        D.24611 = __s2 + 2;
        D.24612 = *D.24611;
        D.24613 = (int) D.24612;
        __result = D.24610 - D.24613;
        D.24614 = __s2_len > 2;
        D.24594 = __result == 0;
        D.24615 = D.24614 & D.24594;
        if (D.24615 != 0) goto <D.24616>; else goto <D.24617>;
        <D.24616>:
        D.24618 = &MEM[(void *)"--llvm" + 3B];
        D.24619 = *D.24618;
        D.24620 = (int) D.24619;
        D.24621 = __s2 + 3;
        D.24622 = *D.24621;
        D.24623 = (int) D.24622;
        __result = D.24620 - D.24623;
        <D.24617>:
        <D.24607>:
        <D.24597>:
      }
      D.23499 = __result;
    }
    iftmp.15 = -D.23499;
    goto <D.24624>;
    <D.24587>:
    i.6 = (unsigned int) i;
    D.24255 = i.6 * 4;
    D.24256 = argv + D.24255;
    D.24257 = *D.24256;
    iftmp.15 = __builtin_strcmp (D.24257, "--llvm");
    <D.24624>:
    D.23500 = iftmp.15;
  }
  if (D.23500 == 0) goto <D.24625>; else goto <D.24626>;
  <D.24625>:
  stderr.14 = stderr;
  fprintf (stderr.14, "Mono Warning: --llvm not enabled in this runtime.\n");
  goto <D.24627>;
  <D.24626>:
  i.6 = (unsigned int) i;
  D.24255 = i.6 * 4;
  D.24256 = argv + D.24255;
  D.24257 = *D.24256;
  stderr.14 = stderr;
  fprintf (stderr.14, "Unsupported command line option: \'%s\'\n", D.24257);
  exit (1);
  <D.24627>:
  <D.24584>:
  <D.24534>:
  <D.24491>:
  <D.24367>:
  <D.24364>:
  <D.24360>:
  <D.24317>:
  <D.24312>:
  <D.24307>:
  <D.24264>:
  i = i + 1;
  <D.23502>:
  if (i < argc) goto <D.23501>; else goto <D.23387>;
  <D.23387>:
  if (trace_options != 0B) goto <D.24628>; else goto <D.24629>;
  <D.24628>:
  mono_jit_trace_calls.16 = mono_trace_parse_options (trace_options);
  mono_jit_trace_calls = mono_jit_trace_calls.16;
  mono_jit_trace_calls.17 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.17 == 0B) goto <D.24632>; else goto <D.24633>;
  <D.24632>:
  exit (1);
  <D.24633>:
  <D.24629>:
  if (mini_verbose != 0) goto <D.24634>; else goto <D.24635>;
  <D.24634>:
  mini_verbose.18 = (unsigned int) mini_verbose;
  mono_set_verbose_level (mini_verbose.18);
  <D.24635>:
}


mono_main (int argc, char * * argv)
{
  const gchar * D.24637;
  unsigned int i.19;
  unsigned int D.24645;
  char * * D.24646;
  char * D.24647;
  char D.24648;
  int D.23559;
  int iftmp.20;
  int D.23558;
  const char[13] * D.24653;
  unsigned char D.24654;
  int D.24655;
  unsigned char D.24656;
  int D.24657;
  _Bool D.24658;
  _Bool D.24659;
  _Bool D.24660;
  const unsigned char * D.24663;
  unsigned char D.24664;
  int D.24665;
  const unsigned char * D.24666;
  unsigned char D.24667;
  int D.24668;
  _Bool D.24669;
  _Bool D.24670;
  const unsigned char * D.24673;
  unsigned char D.24674;
  int D.24675;
  const unsigned char * D.24676;
  unsigned char D.24677;
  int D.24678;
  _Bool D.24679;
  _Bool D.24680;
  const unsigned char * D.24683;
  unsigned char D.24684;
  int D.24685;
  const unsigned char * D.24686;
  unsigned char D.24687;
  int D.24688;
  int D.24693;
  char * D.24696;
  unsigned int mono_single_method_regression_opt.21;
  int D.23578;
  int iftmp.22;
  int D.23577;
  const char[10] * D.24705;
  unsigned char D.24706;
  int D.24707;
  unsigned char D.24708;
  int D.24709;
  _Bool D.24710;
  _Bool D.24711;
  _Bool D.24712;
  const unsigned char * D.24715;
  unsigned char D.24716;
  int D.24717;
  const unsigned char * D.24718;
  unsigned char D.24719;
  int D.24720;
  _Bool D.24721;
  _Bool D.24722;
  const unsigned char * D.24725;
  unsigned char D.24726;
  int D.24727;
  const unsigned char * D.24728;
  unsigned char D.24729;
  int D.24730;
  _Bool D.24731;
  _Bool D.24732;
  const unsigned char * D.24735;
  unsigned char D.24736;
  int D.24737;
  const unsigned char * D.24738;
  unsigned char D.24739;
  int D.24740;
  int D.23587;
  int iftmp.23;
  int D.23586;
  const char[3] * D.24746;
  unsigned char D.24747;
  int D.24748;
  unsigned char D.24749;
  int D.24750;
  _Bool D.24751;
  _Bool D.24752;
  _Bool D.24753;
  const unsigned char * D.24756;
  unsigned char D.24757;
  int D.24758;
  const unsigned char * D.24759;
  unsigned char D.24760;
  int D.24761;
  _Bool D.24762;
  _Bool D.24763;
  const unsigned char * D.24766;
  unsigned char D.24767;
  int D.24768;
  const unsigned char * D.24769;
  unsigned char D.24770;
  int D.24771;
  _Bool D.24772;
  _Bool D.24773;
  const unsigned char * D.24776;
  unsigned char D.24777;
  int D.24778;
  const unsigned char * D.24779;
  unsigned char D.24780;
  int D.24781;
  int D.23596;
  int iftmp.24;
  int D.23595;
  const char[10] * D.24788;
  unsigned char D.24789;
  int D.24790;
  unsigned char D.24791;
  int D.24792;
  _Bool D.24793;
  _Bool D.24794;
  _Bool D.24795;
  const unsigned char * D.24798;
  unsigned char D.24799;
  int D.24800;
  const unsigned char * D.24801;
  unsigned char D.24802;
  int D.24803;
  _Bool D.24804;
  _Bool D.24805;
  const unsigned char * D.24808;
  unsigned char D.24809;
  int D.24810;
  const unsigned char * D.24811;
  unsigned char D.24812;
  int D.24813;
  _Bool D.24814;
  _Bool D.24815;
  const unsigned char * D.24818;
  unsigned char D.24819;
  int D.24820;
  const unsigned char * D.24821;
  unsigned char D.24822;
  int D.24823;
  int D.23605;
  int iftmp.25;
  int D.23604;
  const char[3] * D.24829;
  unsigned char D.24830;
  int D.24831;
  unsigned char D.24832;
  int D.24833;
  _Bool D.24834;
  _Bool D.24835;
  _Bool D.24836;
  const unsigned char * D.24839;
  unsigned char D.24840;
  int D.24841;
  const unsigned char * D.24842;
  unsigned char D.24843;
  int D.24844;
  _Bool D.24845;
  _Bool D.24846;
  const unsigned char * D.24849;
  unsigned char D.24850;
  int D.24851;
  const unsigned char * D.24852;
  unsigned char D.24853;
  int D.24854;
  _Bool D.24855;
  _Bool D.24856;
  const unsigned char * D.24859;
  unsigned char D.24860;
  int D.24861;
  const unsigned char * D.24862;
  unsigned char D.24863;
  int D.24864;
  const char * iftmp.26;
  struct MonoImage * D.24869;
  int D.24875;
  int D.23618;
  int iftmp.27;
  int D.23617;
  const char[7] * D.24881;
  unsigned char D.24882;
  int D.24883;
  unsigned char D.24884;
  int D.24885;
  _Bool D.24886;
  _Bool D.24887;
  _Bool D.24888;
  const unsigned char * D.24891;
  unsigned char D.24892;
  int D.24893;
  const unsigned char * D.24894;
  unsigned char D.24895;
  int D.24896;
  _Bool D.24897;
  _Bool D.24898;
  const unsigned char * D.24901;
  unsigned char D.24902;
  int D.24903;
  const unsigned char * D.24904;
  unsigned char D.24905;
  int D.24906;
  _Bool D.24907;
  _Bool D.24908;
  const unsigned char * D.24911;
  unsigned char D.24912;
  int D.24913;
  const unsigned char * D.24914;
  unsigned char D.24915;
  int D.24916;
  int D.23627;
  int iftmp.28;
  int D.23626;
  const char[3] * D.24922;
  unsigned char D.24923;
  int D.24924;
  unsigned char D.24925;
  int D.24926;
  _Bool D.24927;
  _Bool D.24928;
  _Bool D.24929;
  const unsigned char * D.24932;
  unsigned char D.24933;
  int D.24934;
  const unsigned char * D.24935;
  unsigned char D.24936;
  int D.24937;
  _Bool D.24938;
  _Bool D.24939;
  const unsigned char * D.24942;
  unsigned char D.24943;
  int D.24944;
  const unsigned char * D.24945;
  unsigned char D.24946;
  int D.24947;
  _Bool D.24948;
  _Bool D.24949;
  const unsigned char * D.24952;
  unsigned char D.24953;
  int D.24954;
  const unsigned char * D.24955;
  unsigned char D.24956;
  int D.24957;
  int D.23636;
  int iftmp.29;
  int D.23635;
  const char[13] * D.24962;
  unsigned char D.24963;
  int D.24964;
  unsigned char D.24965;
  int D.24966;
  _Bool D.24967;
  _Bool D.24968;
  _Bool D.24969;
  const unsigned char * D.24972;
  unsigned char D.24973;
  int D.24974;
  const unsigned char * D.24975;
  unsigned char D.24976;
  int D.24977;
  _Bool D.24978;
  _Bool D.24979;
  const unsigned char * D.24982;
  unsigned char D.24983;
  int D.24984;
  const unsigned char * D.24985;
  unsigned char D.24986;
  int D.24987;
  _Bool D.24988;
  _Bool D.24989;
  const unsigned char * D.24992;
  unsigned char D.24993;
  int D.24994;
  const unsigned char * D.24995;
  unsigned char D.24996;
  int D.24997;
  int D.23645;
  int iftmp.30;
  int D.23644;
  const char[13] * D.25004;
  unsigned char D.25005;
  int D.25006;
  unsigned char D.25007;
  int D.25008;
  _Bool D.25009;
  _Bool D.25010;
  _Bool D.25011;
  const unsigned char * D.25014;
  unsigned char D.25015;
  int D.25016;
  const unsigned char * D.25017;
  unsigned char D.25018;
  int D.25019;
  _Bool D.25020;
  _Bool D.25021;
  const unsigned char * D.25024;
  unsigned char D.25025;
  int D.25026;
  const unsigned char * D.25027;
  unsigned char D.25028;
  int D.25029;
  _Bool D.25030;
  _Bool D.25031;
  const unsigned char * D.25034;
  unsigned char D.25035;
  int D.25036;
  const unsigned char * D.25037;
  unsigned char D.25038;
  int D.25039;
  int D.23654;
  int iftmp.31;
  int D.23653;
  const char[13] * D.25046;
  unsigned char D.25047;
  int D.25048;
  unsigned char D.25049;
  int D.25050;
  _Bool D.25051;
  _Bool D.25052;
  _Bool D.25053;
  const unsigned char * D.25056;
  unsigned char D.25057;
  int D.25058;
  const unsigned char * D.25059;
  unsigned char D.25060;
  int D.25061;
  _Bool D.25062;
  _Bool D.25063;
  const unsigned char * D.25066;
  unsigned char D.25067;
  int D.25068;
  const unsigned char * D.25069;
  unsigned char D.25070;
  int D.25071;
  _Bool D.25072;
  _Bool D.25073;
  const unsigned char * D.25076;
  unsigned char D.25077;
  int D.25078;
  const unsigned char * D.25079;
  unsigned char D.25080;
  int D.25081;
  int D.23663;
  int iftmp.32;
  int D.23662;
  const char[11] * D.25088;
  unsigned char D.25089;
  int D.25090;
  unsigned char D.25091;
  int D.25092;
  _Bool D.25093;
  _Bool D.25094;
  _Bool D.25095;
  const unsigned char * D.25098;
  unsigned char D.25099;
  int D.25100;
  const unsigned char * D.25101;
  unsigned char D.25102;
  int D.25103;
  _Bool D.25104;
  _Bool D.25105;
  const unsigned char * D.25108;
  unsigned char D.25109;
  int D.25110;
  const unsigned char * D.25111;
  unsigned char D.25112;
  int D.25113;
  _Bool D.25114;
  _Bool D.25115;
  const unsigned char * D.25118;
  unsigned char D.25119;
  int D.25120;
  const unsigned char * D.25121;
  unsigned char D.25122;
  int D.25123;
  int D.25127;
  int D.25130;
  struct _IO_FILE * stderr.33;
  struct FILE * mini_stats_fd.34;
  int D.25136;
  const char * D.25139;
  int D.25141;
  const char * D.25144;
  int D.23699;
  int iftmp.35;
  int D.23698;
  const char[10] * D.25149;
  unsigned char D.25150;
  int D.25151;
  unsigned char D.25152;
  int D.25153;
  _Bool D.25154;
  _Bool D.25155;
  _Bool D.25156;
  const unsigned char * D.25159;
  unsigned char D.25160;
  int D.25161;
  const unsigned char * D.25162;
  unsigned char D.25163;
  int D.25164;
  _Bool D.25165;
  _Bool D.25166;
  const unsigned char * D.25169;
  unsigned char D.25170;
  int D.25171;
  const unsigned char * D.25172;
  unsigned char D.25173;
  int D.25174;
  _Bool D.25175;
  _Bool D.25176;
  const unsigned char * D.25179;
  unsigned char D.25180;
  int D.25181;
  const unsigned char * D.25182;
  unsigned char D.25183;
  int D.25184;
  int D.23708;
  int iftmp.36;
  int D.23707;
  const char[11] * D.25192;
  unsigned char D.25193;
  int D.25194;
  unsigned char D.25195;
  int D.25196;
  _Bool D.25197;
  _Bool D.25198;
  _Bool D.25199;
  const unsigned char * D.25202;
  unsigned char D.25203;
  int D.25204;
  const unsigned char * D.25205;
  unsigned char D.25206;
  int D.25207;
  _Bool D.25208;
  _Bool D.25209;
  const unsigned char * D.25212;
  unsigned char D.25213;
  int D.25214;
  const unsigned char * D.25215;
  unsigned char D.25216;
  int D.25217;
  _Bool D.25218;
  _Bool D.25219;
  const unsigned char * D.25222;
  unsigned char D.25223;
  int D.25224;
  const unsigned char * D.25225;
  unsigned char D.25226;
  int D.25227;
  int D.23717;
  int iftmp.37;
  int D.23716;
  const char[9] * D.25235;
  unsigned char D.25236;
  int D.25237;
  unsigned char D.25238;
  int D.25239;
  _Bool D.25240;
  _Bool D.25241;
  _Bool D.25242;
  const unsigned char * D.25245;
  unsigned char D.25246;
  int D.25247;
  const unsigned char * D.25248;
  unsigned char D.25249;
  int D.25250;
  _Bool D.25251;
  _Bool D.25252;
  const unsigned char * D.25255;
  unsigned char D.25256;
  int D.25257;
  const unsigned char * D.25258;
  unsigned char D.25259;
  int D.25260;
  _Bool D.25261;
  _Bool D.25262;
  const unsigned char * D.25265;
  unsigned char D.25266;
  int D.25267;
  const unsigned char * D.25268;
  unsigned char D.25269;
  int D.25270;
  int D.23726;
  int iftmp.38;
  int D.23725;
  const char[11] * D.25280;
  unsigned char D.25281;
  int D.25282;
  unsigned char D.25283;
  int D.25284;
  _Bool D.25285;
  _Bool D.25286;
  _Bool D.25287;
  const unsigned char * D.25290;
  unsigned char D.25291;
  int D.25292;
  const unsigned char * D.25293;
  unsigned char D.25294;
  int D.25295;
  _Bool D.25296;
  _Bool D.25297;
  const unsigned char * D.25300;
  unsigned char D.25301;
  int D.25302;
  const unsigned char * D.25303;
  unsigned char D.25304;
  int D.25305;
  _Bool D.25306;
  _Bool D.25307;
  const unsigned char * D.25310;
  unsigned char D.25311;
  int D.25312;
  const unsigned char * D.25313;
  unsigned char D.25314;
  int D.25315;
  int D.23735;
  int iftmp.39;
  int D.23734;
  const char[8] * D.25325;
  unsigned char D.25326;
  int D.25327;
  unsigned char D.25328;
  int D.25329;
  _Bool D.25330;
  _Bool D.25331;
  _Bool D.25332;
  const unsigned char * D.25335;
  unsigned char D.25336;
  int D.25337;
  const unsigned char * D.25338;
  unsigned char D.25339;
  int D.25340;
  _Bool D.25341;
  _Bool D.25342;
  const unsigned char * D.25345;
  unsigned char D.25346;
  int D.25347;
  const unsigned char * D.25348;
  unsigned char D.25349;
  int D.25350;
  _Bool D.25351;
  _Bool D.25352;
  const unsigned char * D.25355;
  unsigned char D.25356;
  int D.25357;
  const unsigned char * D.25358;
  unsigned char D.25359;
  int D.25360;
  int D.25365;
  int D.23753;
  int iftmp.40;
  int D.23752;
  const char[12] * D.25372;
  unsigned char D.25373;
  int D.25374;
  unsigned char D.25375;
  int D.25376;
  _Bool D.25377;
  _Bool D.25378;
  _Bool D.25379;
  const unsigned char * D.25382;
  unsigned char D.25383;
  int D.25384;
  const unsigned char * D.25385;
  unsigned char D.25386;
  int D.25387;
  _Bool D.25388;
  _Bool D.25389;
  const unsigned char * D.25392;
  unsigned char D.25393;
  int D.25394;
  const unsigned char * D.25395;
  unsigned char D.25396;
  int D.25397;
  _Bool D.25398;
  _Bool D.25399;
  const unsigned char * D.25402;
  unsigned char D.25403;
  int D.25404;
  const unsigned char * D.25405;
  unsigned char D.25406;
  int D.25407;
  int D.23763;
  int iftmp.41;
  int D.23762;
  const char[8] * D.25415;
  unsigned char D.25416;
  int D.25417;
  unsigned char D.25418;
  int D.25419;
  _Bool D.25420;
  _Bool D.25421;
  _Bool D.25422;
  const unsigned char * D.25425;
  unsigned char D.25426;
  int D.25427;
  const unsigned char * D.25428;
  unsigned char D.25429;
  int D.25430;
  _Bool D.25431;
  _Bool D.25432;
  const unsigned char * D.25435;
  unsigned char D.25436;
  int D.25437;
  const unsigned char * D.25438;
  unsigned char D.25439;
  int D.25440;
  _Bool D.25441;
  _Bool D.25442;
  const unsigned char * D.25445;
  unsigned char D.25446;
  int D.25447;
  const unsigned char * D.25448;
  unsigned char D.25449;
  int D.25450;
  int D.25456;
  int D.23772;
  int iftmp.42;
  int D.23771;
  const char[14] * D.25463;
  unsigned char D.25464;
  int D.25465;
  unsigned char D.25466;
  int D.25467;
  _Bool D.25468;
  _Bool D.25469;
  _Bool D.25470;
  const unsigned char * D.25473;
  unsigned char D.25474;
  int D.25475;
  const unsigned char * D.25476;
  unsigned char D.25477;
  int D.25478;
  _Bool D.25479;
  _Bool D.25480;
  const unsigned char * D.25483;
  unsigned char D.25484;
  int D.25485;
  const unsigned char * D.25486;
  unsigned char D.25487;
  int D.25488;
  _Bool D.25489;
  _Bool D.25490;
  const unsigned char * D.25493;
  unsigned char D.25494;
  int D.25495;
  const unsigned char * D.25496;
  unsigned char D.25497;
  int D.25498;
  int D.25502;
  struct MonoMethodDesc * mono_break_at_bb_method.43;
  struct MonoMethodDesc * mono_break_at_bb_method.44;
  int mono_break_at_bb_bb_num.45;
  int D.23781;
  int iftmp.46;
  int D.23780;
  const char[19] * D.25514;
  unsigned char D.25515;
  int D.25516;
  unsigned char D.25517;
  int D.25518;
  _Bool D.25519;
  _Bool D.25520;
  _Bool D.25521;
  const unsigned char * D.25524;
  unsigned char D.25525;
  int D.25526;
  const unsigned char * D.25527;
  unsigned char D.25528;
  int D.25529;
  _Bool D.25530;
  _Bool D.25531;
  const unsigned char * D.25534;
  unsigned char D.25535;
  int D.25536;
  const unsigned char * D.25537;
  unsigned char D.25538;
  int D.25539;
  _Bool D.25540;
  _Bool D.25541;
  const unsigned char * D.25544;
  unsigned char D.25545;
  int D.25546;
  const unsigned char * D.25547;
  unsigned char D.25548;
  int D.25549;
  struct MonoMethodDesc * mono_inject_async_exc_method.47;
  struct MonoMethodDesc * mono_inject_async_exc_method.48;
  int mono_inject_async_exc_pos.49;
  int D.23790;
  int iftmp.50;
  int D.23789;
  const char[13] * D.25564;
  unsigned char D.25565;
  int D.25566;
  unsigned char D.25567;
  int D.25568;
  _Bool D.25569;
  _Bool D.25570;
  _Bool D.25571;
  const unsigned char * D.25574;
  unsigned char D.25575;
  int D.25576;
  const unsigned char * D.25577;
  unsigned char D.25578;
  int D.25579;
  _Bool D.25580;
  _Bool D.25581;
  const unsigned char * D.25584;
  unsigned char D.25585;
  int D.25586;
  const unsigned char * D.25587;
  unsigned char D.25588;
  int D.25589;
  _Bool D.25590;
  _Bool D.25591;
  const unsigned char * D.25594;
  unsigned char D.25595;
  int D.25596;
  const unsigned char * D.25597;
  unsigned char D.25598;
  int D.25599;
  int D.23799;
  int iftmp.51;
  int D.23798;
  const char[11] * D.25607;
  unsigned char D.25608;
  int D.25609;
  unsigned char D.25610;
  int D.25611;
  _Bool D.25612;
  _Bool D.25613;
  _Bool D.25614;
  const unsigned char * D.25617;
  unsigned char D.25618;
  int D.25619;
  const unsigned char * D.25620;
  unsigned char D.25621;
  int D.25622;
  _Bool D.25623;
  _Bool D.25624;
  const unsigned char * D.25627;
  unsigned char D.25628;
  int D.25629;
  const unsigned char * D.25630;
  unsigned char D.25631;
  int D.25632;
  _Bool D.25633;
  _Bool D.25634;
  const unsigned char * D.25637;
  unsigned char D.25638;
  int D.25639;
  const unsigned char * D.25640;
  unsigned char D.25641;
  int D.25642;
  int D.23808;
  int iftmp.52;
  int D.23807;
  const char[15] * D.25650;
  unsigned char D.25651;
  int D.25652;
  unsigned char D.25653;
  int D.25654;
  _Bool D.25655;
  _Bool D.25656;
  _Bool D.25657;
  const unsigned char * D.25660;
  unsigned char D.25661;
  int D.25662;
  const unsigned char * D.25663;
  unsigned char D.25664;
  int D.25665;
  _Bool D.25666;
  _Bool D.25667;
  const unsigned char * D.25670;
  unsigned char D.25671;
  int D.25672;
  const unsigned char * D.25673;
  unsigned char D.25674;
  int D.25675;
  _Bool D.25676;
  _Bool D.25677;
  const unsigned char * D.25680;
  unsigned char D.25681;
  int D.25682;
  const unsigned char * D.25683;
  unsigned char D.25684;
  int D.25685;
  int D.23817;
  int iftmp.53;
  int D.23816;
  const char[8] * D.25693;
  unsigned char D.25694;
  int D.25695;
  unsigned char D.25696;
  int D.25697;
  _Bool D.25698;
  _Bool D.25699;
  _Bool D.25700;
  const unsigned char * D.25703;
  unsigned char D.25704;
  int D.25705;
  const unsigned char * D.25706;
  unsigned char D.25707;
  int D.25708;
  _Bool D.25709;
  _Bool D.25710;
  const unsigned char * D.25713;
  unsigned char D.25714;
  int D.25715;
  const unsigned char * D.25716;
  unsigned char D.25717;
  int D.25718;
  _Bool D.25719;
  _Bool D.25720;
  const unsigned char * D.25723;
  unsigned char D.25724;
  int D.25725;
  const unsigned char * D.25726;
  unsigned char D.25727;
  int D.25728;
  int D.23826;
  int iftmp.54;
  int D.23825;
  const char[6] * D.25736;
  unsigned char D.25737;
  int D.25738;
  unsigned char D.25739;
  int D.25740;
  _Bool D.25741;
  _Bool D.25742;
  _Bool D.25743;
  const unsigned char * D.25746;
  unsigned char D.25747;
  int D.25748;
  const unsigned char * D.25749;
  unsigned char D.25750;
  int D.25751;
  _Bool D.25752;
  _Bool D.25753;
  const unsigned char * D.25756;
  unsigned char D.25757;
  int D.25758;
  const unsigned char * D.25759;
  unsigned char D.25760;
  int D.25761;
  _Bool D.25762;
  _Bool D.25763;
  const unsigned char * D.25766;
  unsigned char D.25767;
  int D.25768;
  const unsigned char * D.25769;
  unsigned char D.25770;
  int D.25771;
  int D.25776;
  int D.25780;
  const char * D.25783;
  int D.25784;
  int D.23853;
  int iftmp.55;
  int D.23852;
  const char[14] * D.25789;
  unsigned char D.25790;
  int D.25791;
  unsigned char D.25792;
  int D.25793;
  _Bool D.25794;
  _Bool D.25795;
  _Bool D.25796;
  const unsigned char * D.25799;
  unsigned char D.25800;
  int D.25801;
  const unsigned char * D.25802;
  unsigned char D.25803;
  int D.25804;
  _Bool D.25805;
  _Bool D.25806;
  const unsigned char * D.25809;
  unsigned char D.25810;
  int D.25811;
  const unsigned char * D.25812;
  unsigned char D.25813;
  int D.25814;
  _Bool D.25815;
  _Bool D.25816;
  const unsigned char * D.25819;
  unsigned char D.25820;
  int D.25821;
  const unsigned char * D.25822;
  unsigned char D.25823;
  int D.25824;
  int D.25829;
  int D.23871;
  int iftmp.56;
  int D.23870;
  const char[9] * D.25836;
  unsigned char D.25837;
  int D.25838;
  unsigned char D.25839;
  int D.25840;
  _Bool D.25841;
  _Bool D.25842;
  _Bool D.25843;
  const unsigned char * D.25846;
  unsigned char D.25847;
  int D.25848;
  const unsigned char * D.25849;
  unsigned char D.25850;
  int D.25851;
  _Bool D.25852;
  _Bool D.25853;
  const unsigned char * D.25856;
  unsigned char D.25857;
  int D.25858;
  const unsigned char * D.25859;
  unsigned char D.25860;
  int D.25861;
  _Bool D.25862;
  _Bool D.25863;
  const unsigned char * D.25866;
  unsigned char D.25867;
  int D.25868;
  const unsigned char * D.25869;
  unsigned char D.25870;
  int D.25871;
  int D.23880;
  int iftmp.57;
  int D.23879;
  const char[10] * D.25879;
  unsigned char D.25880;
  int D.25881;
  unsigned char D.25882;
  int D.25883;
  _Bool D.25884;
  _Bool D.25885;
  _Bool D.25886;
  const unsigned char * D.25889;
  unsigned char D.25890;
  int D.25891;
  const unsigned char * D.25892;
  unsigned char D.25893;
  int D.25894;
  _Bool D.25895;
  _Bool D.25896;
  const unsigned char * D.25899;
  unsigned char D.25900;
  int D.25901;
  const unsigned char * D.25902;
  unsigned char D.25903;
  int D.25904;
  _Bool D.25905;
  _Bool D.25906;
  const unsigned char * D.25909;
  unsigned char D.25910;
  int D.25911;
  const unsigned char * D.25912;
  unsigned char D.25913;
  int D.25914;
  int D.25919;
  int D.25923;
  void * D.25928;
  int D.25930;
  int D.23916;
  int iftmp.58;
  int D.23915;
  const char[10] * D.25937;
  unsigned char D.25938;
  int D.25939;
  unsigned char D.25940;
  int D.25941;
  _Bool D.25942;
  _Bool D.25943;
  _Bool D.25944;
  const unsigned char * D.25947;
  unsigned char D.25948;
  int D.25949;
  const unsigned char * D.25950;
  unsigned char D.25951;
  int D.25952;
  _Bool D.25953;
  _Bool D.25954;
  const unsigned char * D.25957;
  unsigned char D.25958;
  int D.25959;
  const unsigned char * D.25960;
  unsigned char D.25961;
  int D.25962;
  _Bool D.25963;
  _Bool D.25964;
  const unsigned char * D.25967;
  unsigned char D.25968;
  int D.25969;
  const unsigned char * D.25970;
  unsigned char D.25971;
  int D.25972;
  int D.25979;
  const char * D.25984;
  int D.23934;
  int iftmp.59;
  int D.23933;
  const char[8] * D.25989;
  unsigned char D.25990;
  int D.25991;
  unsigned char D.25992;
  int D.25993;
  _Bool D.25994;
  _Bool D.25995;
  _Bool D.25996;
  const unsigned char * D.25999;
  unsigned char D.26000;
  int D.26001;
  const unsigned char * D.26002;
  unsigned char D.26003;
  int D.26004;
  _Bool D.26005;
  _Bool D.26006;
  const unsigned char * D.26009;
  unsigned char D.26010;
  int D.26011;
  const unsigned char * D.26012;
  unsigned char D.26013;
  int D.26014;
  _Bool D.26015;
  _Bool D.26016;
  const unsigned char * D.26019;
  unsigned char D.26020;
  int D.26021;
  const unsigned char * D.26022;
  unsigned char D.26023;
  int D.26024;
  int D.23943;
  int iftmp.60;
  int D.23942;
  const char[8] * D.26034;
  unsigned char D.26035;
  int D.26036;
  unsigned char D.26037;
  int D.26038;
  _Bool D.26039;
  _Bool D.26040;
  _Bool D.26041;
  const unsigned char * D.26044;
  unsigned char D.26045;
  int D.26046;
  const unsigned char * D.26047;
  unsigned char D.26048;
  int D.26049;
  _Bool D.26050;
  _Bool D.26051;
  const unsigned char * D.26054;
  unsigned char D.26055;
  int D.26056;
  const unsigned char * D.26057;
  unsigned char D.26058;
  int D.26059;
  _Bool D.26060;
  _Bool D.26061;
  const unsigned char * D.26064;
  unsigned char D.26065;
  int D.26066;
  const unsigned char * D.26067;
  unsigned char D.26068;
  int D.26069;
  int D.26074;
  int D.26077;
  int D.26081;
  char * D.26084;
  int D.23971;
  int iftmp.61;
  int D.23970;
  const char[11] * D.26089;
  unsigned char D.26090;
  int D.26091;
  unsigned char D.26092;
  int D.26093;
  _Bool D.26094;
  _Bool D.26095;
  _Bool D.26096;
  const unsigned char * D.26099;
  unsigned char D.26100;
  int D.26101;
  const unsigned char * D.26102;
  unsigned char D.26103;
  int D.26104;
  _Bool D.26105;
  _Bool D.26106;
  const unsigned char * D.26109;
  unsigned char D.26110;
  int D.26111;
  const unsigned char * D.26112;
  unsigned char D.26113;
  int D.26114;
  _Bool D.26115;
  _Bool D.26116;
  const unsigned char * D.26119;
  unsigned char D.26120;
  int D.26121;
  const unsigned char * D.26122;
  unsigned char D.26123;
  int D.26124;
  int D.26129;
  int D.23989;
  int iftmp.62;
  int D.23988;
  const char[20] * D.26135;
  unsigned char D.26136;
  int D.26137;
  unsigned char D.26138;
  int D.26139;
  _Bool D.26140;
  _Bool D.26141;
  _Bool D.26142;
  const unsigned char * D.26145;
  unsigned char D.26146;
  int D.26147;
  const unsigned char * D.26148;
  unsigned char D.26149;
  int D.26150;
  _Bool D.26151;
  _Bool D.26152;
  const unsigned char * D.26155;
  unsigned char D.26156;
  int D.26157;
  const unsigned char * D.26158;
  unsigned char D.26159;
  int D.26160;
  _Bool D.26161;
  _Bool D.26162;
  const unsigned char * D.26165;
  unsigned char D.26166;
  int D.26167;
  const unsigned char * D.26168;
  unsigned char D.26169;
  int D.26170;
  int D.23998;
  int iftmp.63;
  int D.23997;
  const char[9] * D.26178;
  unsigned char D.26179;
  int D.26180;
  unsigned char D.26181;
  int D.26182;
  _Bool D.26183;
  _Bool D.26184;
  _Bool D.26185;
  const unsigned char * D.26188;
  unsigned char D.26189;
  int D.26190;
  const unsigned char * D.26191;
  unsigned char D.26192;
  int D.26193;
  _Bool D.26194;
  _Bool D.26195;
  const unsigned char * D.26198;
  unsigned char D.26199;
  int D.26200;
  const unsigned char * D.26201;
  unsigned char D.26202;
  int D.26203;
  _Bool D.26204;
  _Bool D.26205;
  const unsigned char * D.26208;
  unsigned char D.26209;
  int D.26210;
  const unsigned char * D.26211;
  unsigned char D.26212;
  int D.26213;
  int D.24007;
  int iftmp.64;
  int D.24006;
  const char[14] * D.26221;
  unsigned char D.26222;
  int D.26223;
  unsigned char D.26224;
  int D.26225;
  _Bool D.26226;
  _Bool D.26227;
  _Bool D.26228;
  const unsigned char * D.26231;
  unsigned char D.26232;
  int D.26233;
  const unsigned char * D.26234;
  unsigned char D.26235;
  int D.26236;
  _Bool D.26237;
  _Bool D.26238;
  const unsigned char * D.26241;
  unsigned char D.26242;
  int D.26243;
  const unsigned char * D.26244;
  unsigned char D.26245;
  int D.26246;
  _Bool D.26247;
  _Bool D.26248;
  const unsigned char * D.26251;
  unsigned char D.26252;
  int D.26253;
  const unsigned char * D.26254;
  unsigned char D.26255;
  int D.26256;
  int D.24016;
  int iftmp.65;
  int D.24015;
  const char[4] * D.26264;
  unsigned char D.26265;
  int D.26266;
  unsigned char D.26267;
  int D.26268;
  _Bool D.26269;
  _Bool D.26270;
  _Bool D.26271;
  const unsigned char * D.26274;
  unsigned char D.26275;
  int D.26276;
  const unsigned char * D.26277;
  unsigned char D.26278;
  int D.26279;
  _Bool D.26280;
  _Bool D.26281;
  const unsigned char * D.26284;
  unsigned char D.26285;
  int D.26286;
  const unsigned char * D.26287;
  unsigned char D.26288;
  int D.26289;
  _Bool D.26290;
  _Bool D.26291;
  const unsigned char * D.26294;
  unsigned char D.26295;
  int D.26296;
  const unsigned char * D.26297;
  unsigned char D.26298;
  int D.26299;
  int D.24025;
  int iftmp.66;
  int D.24024;
  const char[8] * D.26307;
  unsigned char D.26308;
  int D.26309;
  unsigned char D.26310;
  int D.26311;
  _Bool D.26312;
  _Bool D.26313;
  _Bool D.26314;
  const unsigned char * D.26317;
  unsigned char D.26318;
  int D.26319;
  const unsigned char * D.26320;
  unsigned char D.26321;
  int D.26322;
  _Bool D.26323;
  _Bool D.26324;
  const unsigned char * D.26327;
  unsigned char D.26328;
  int D.26329;
  const unsigned char * D.26330;
  unsigned char D.26331;
  int D.26332;
  _Bool D.26333;
  _Bool D.26334;
  const unsigned char * D.26337;
  unsigned char D.26338;
  int D.26339;
  const unsigned char * D.26340;
  unsigned char D.26341;
  int D.26342;
  int D.24034;
  int iftmp.67;
  int D.24033;
  const char[11] * D.26350;
  unsigned char D.26351;
  int D.26352;
  unsigned char D.26353;
  int D.26354;
  _Bool D.26355;
  _Bool D.26356;
  _Bool D.26357;
  const unsigned char * D.26360;
  unsigned char D.26361;
  int D.26362;
  const unsigned char * D.26363;
  unsigned char D.26364;
  int D.26365;
  _Bool D.26366;
  _Bool D.26367;
  const unsigned char * D.26370;
  unsigned char D.26371;
  int D.26372;
  const unsigned char * D.26373;
  unsigned char D.26374;
  int D.26375;
  _Bool D.26376;
  _Bool D.26377;
  const unsigned char * D.26380;
  unsigned char D.26381;
  int D.26382;
  const unsigned char * D.26383;
  unsigned char D.26384;
  int D.26385;
  int D.24043;
  int iftmp.68;
  int D.24042;
  const char[10] * D.26394;
  unsigned char D.26395;
  int D.26396;
  unsigned char D.26397;
  int D.26398;
  _Bool D.26399;
  _Bool D.26400;
  _Bool D.26401;
  const unsigned char * D.26404;
  unsigned char D.26405;
  int D.26406;
  const unsigned char * D.26407;
  unsigned char D.26408;
  int D.26409;
  _Bool D.26410;
  _Bool D.26411;
  const unsigned char * D.26414;
  unsigned char D.26415;
  int D.26416;
  const unsigned char * D.26417;
  unsigned char D.26418;
  int D.26419;
  _Bool D.26420;
  _Bool D.26421;
  const unsigned char * D.26424;
  unsigned char D.26425;
  int D.26426;
  const unsigned char * D.26427;
  unsigned char D.26428;
  int D.26429;
  int D.24052;
  int iftmp.69;
  int D.24051;
  const char[9] * D.26437;
  unsigned char D.26438;
  int D.26439;
  unsigned char D.26440;
  int D.26441;
  _Bool D.26442;
  _Bool D.26443;
  _Bool D.26444;
  const unsigned char * D.26447;
  unsigned char D.26448;
  int D.26449;
  const unsigned char * D.26450;
  unsigned char D.26451;
  int D.26452;
  _Bool D.26453;
  _Bool D.26454;
  const unsigned char * D.26457;
  unsigned char D.26458;
  int D.26459;
  const unsigned char * D.26460;
  unsigned char D.26461;
  int D.26462;
  _Bool D.26463;
  _Bool D.26464;
  const unsigned char * D.26467;
  unsigned char D.26468;
  int D.26469;
  const unsigned char * D.26470;
  unsigned char D.26471;
  int D.26472;
  int D.24061;
  int iftmp.70;
  int D.24060;
  const char[13] * D.26480;
  unsigned char D.26481;
  int D.26482;
  unsigned char D.26483;
  int D.26484;
  _Bool D.26485;
  _Bool D.26486;
  _Bool D.26487;
  const unsigned char * D.26490;
  unsigned char D.26491;
  int D.26492;
  const unsigned char * D.26493;
  unsigned char D.26494;
  int D.26495;
  _Bool D.26496;
  _Bool D.26497;
  const unsigned char * D.26500;
  unsigned char D.26501;
  int D.26502;
  const unsigned char * D.26503;
  unsigned char D.26504;
  int D.26505;
  _Bool D.26506;
  _Bool D.26507;
  const unsigned char * D.26510;
  unsigned char D.26511;
  int D.26512;
  const unsigned char * D.26513;
  unsigned char D.26514;
  int D.26515;
  int D.26520;
  int D.24079;
  int iftmp.71;
  int D.24078;
  const char[4] * D.26526;
  unsigned char D.26527;
  int D.26528;
  unsigned char D.26529;
  int D.26530;
  _Bool D.26531;
  _Bool D.26532;
  _Bool D.26533;
  const unsigned char * D.26536;
  unsigned char D.26537;
  int D.26538;
  const unsigned char * D.26539;
  unsigned char D.26540;
  int D.26541;
  _Bool D.26542;
  _Bool D.26543;
  const unsigned char * D.26546;
  unsigned char D.26547;
  int D.26548;
  const unsigned char * D.26549;
  unsigned char D.26550;
  int D.26551;
  _Bool D.26552;
  _Bool D.26553;
  const unsigned char * D.26556;
  unsigned char D.26557;
  int D.26558;
  const unsigned char * D.26559;
  unsigned char D.26560;
  int D.26561;
  const char * D.26563;
  int D.26566;
  int D.24088;
  int iftmp.72;
  int D.24087;
  const char[7] * D.26570;
  unsigned char D.26571;
  int D.26572;
  unsigned char D.26573;
  int D.26574;
  _Bool D.26575;
  _Bool D.26576;
  _Bool D.26577;
  const unsigned char * D.26580;
  unsigned char D.26581;
  int D.26582;
  const unsigned char * D.26583;
  unsigned char D.26584;
  int D.26585;
  _Bool D.26586;
  _Bool D.26587;
  const unsigned char * D.26590;
  unsigned char D.26591;
  int D.26592;
  const unsigned char * D.26593;
  unsigned char D.26594;
  int D.26595;
  _Bool D.26596;
  _Bool D.26597;
  const unsigned char * D.26600;
  unsigned char D.26601;
  int D.26602;
  const unsigned char * D.26603;
  unsigned char D.26604;
  int D.26605;
  int D.24097;
  int iftmp.73;
  int D.24096;
  const char[8] * D.26612;
  unsigned char D.26613;
  int D.26614;
  unsigned char D.26615;
  int D.26616;
  _Bool D.26617;
  _Bool D.26618;
  _Bool D.26619;
  const unsigned char * D.26622;
  unsigned char D.26623;
  int D.26624;
  const unsigned char * D.26625;
  unsigned char D.26626;
  int D.26627;
  _Bool D.26628;
  _Bool D.26629;
  const unsigned char * D.26632;
  unsigned char D.26633;
  int D.26634;
  const unsigned char * D.26635;
  unsigned char D.26636;
  int D.26637;
  _Bool D.26638;
  _Bool D.26639;
  const unsigned char * D.26642;
  unsigned char D.26643;
  int D.26644;
  const unsigned char * D.26645;
  unsigned char D.26646;
  int D.26647;
  int D.24106;
  int iftmp.74;
  int D.24105;
  const char[21] * D.26654;
  unsigned char D.26655;
  int D.26656;
  unsigned char D.26657;
  int D.26658;
  _Bool D.26659;
  _Bool D.26660;
  _Bool D.26661;
  const unsigned char * D.26664;
  unsigned char D.26665;
  int D.26666;
  const unsigned char * D.26667;
  unsigned char D.26668;
  int D.26669;
  _Bool D.26670;
  _Bool D.26671;
  const unsigned char * D.26674;
  unsigned char D.26675;
  int D.26676;
  const unsigned char * D.26677;
  unsigned char D.26678;
  int D.26679;
  _Bool D.26680;
  _Bool D.26681;
  const unsigned char * D.26684;
  unsigned char D.26685;
  int D.26686;
  const unsigned char * D.26687;
  unsigned char D.26688;
  int D.26689;
  int D.24115;
  int iftmp.75;
  int D.24114;
  const char[7] * D.26697;
  unsigned char D.26698;
  int D.26699;
  unsigned char D.26700;
  int D.26701;
  _Bool D.26702;
  _Bool D.26703;
  _Bool D.26704;
  const unsigned char * D.26707;
  unsigned char D.26708;
  int D.26709;
  const unsigned char * D.26710;
  unsigned char D.26711;
  int D.26712;
  _Bool D.26713;
  _Bool D.26714;
  const unsigned char * D.26717;
  unsigned char D.26718;
  int D.26719;
  const unsigned char * D.26720;
  unsigned char D.26721;
  int D.26722;
  _Bool D.26723;
  _Bool D.26724;
  const unsigned char * D.26727;
  unsigned char D.26728;
  int D.26729;
  const unsigned char * D.26730;
  unsigned char D.26731;
  int D.26732;
  int D.24124;
  int iftmp.76;
  int D.24123;
  const char[9] * D.26740;
  unsigned char D.26741;
  int D.26742;
  unsigned char D.26743;
  int D.26744;
  _Bool D.26745;
  _Bool D.26746;
  _Bool D.26747;
  const unsigned char * D.26750;
  unsigned char D.26751;
  int D.26752;
  const unsigned char * D.26753;
  unsigned char D.26754;
  int D.26755;
  _Bool D.26756;
  _Bool D.26757;
  const unsigned char * D.26760;
  unsigned char D.26761;
  int D.26762;
  const unsigned char * D.26763;
  unsigned char D.26764;
  int D.26765;
  _Bool D.26766;
  _Bool D.26767;
  const unsigned char * D.26770;
  unsigned char D.26771;
  int D.26772;
  const unsigned char * D.26773;
  unsigned char D.26774;
  int D.26775;
  const gchar * D.26782;
  int mono_compile_aot.77;
  _Bool D.26789;
  _Bool D.26790;
  _Bool D.26791;
  struct MonoTraceSpec * mono_jit_trace_calls.78;
  struct MonoTraceSpec * mono_jit_trace_calls.79;
  int enable_debugging.80;
  struct MonoDomain * domain.81;
  void * * D.26808;
  unsigned int i.82;
  unsigned int D.26810;
  void * * D.26811;
  void * D.26812;
  struct MonoDomain * domain.83;
  unsigned int i.84;
  unsigned int D.26817;
  int D.26818;
  <unnamed type> open_status.85;
  const char * D.26837;
  const char * iftmp.86;
  struct MonoImage * D.26855;
  short unsigned int D.26863;
  int D.26864;
  int D.26865;
  short unsigned int D.26867;
  int D.26868;
  int D.26869;
  struct MonoDomain * D.26870;
  struct MonoDomain * D.26871;
  unsigned int D.26872;
  unsigned int D.26875;
  unsigned int D.26876;
  struct FILE * mini_stats_fd.87;
  char * D.26885;
  char D.26886;
  struct MonoDomain * D.26889;
  struct MonoDomain * D.26898;
  struct MonoDomain * D.26900;
  struct MainThreadArgs main_args;
  struct MonoAssembly * assembly;
  struct MonoMethodDesc * desc;
  struct MonoMethod * method;
  struct MonoCompile * cfg;
  struct MonoDomain * domain;
  MonoImageOpenStatus open_status;
  const char * aname;
  const char * mname;
  char * config_file;
  int i;
  int count;
  guint32 opt;
  guint32 action;
  guint32 recompilation_times;
  MonoGraphOptions mono_graph_options;
  int mini_verbose;
  gboolean enable_profile;
  char * trace_options;
  char * profile_options;
  char * aot_options;
  char * forced_version;
  struct GPtrArray * agents;
  char * attach_options;

  try
    {
      mname = 0B;
      config_file = 0B;
      count = 1;
      action = 4;
      recompilation_times = 1;
      mono_graph_options = 0;
      mini_verbose = 0;
      enable_profile = 0;
      trace_options = 0B;
      profile_options = 0B;
      aot_options = 0B;
      forced_version = 0B;
      agents = 0B;
      attach_options = 0B;
      setlocale (6, "");
      D.24637 = monoeg_g_getenv ("MONO_NO_SMP");
      if (D.24637 != 0B) goto <D.24638>; else goto <D.24639>;
      <D.24638>:
      mono_set_use_smp (0);
      <D.24639>:
      if (0 != 0) goto <D.24640>; else goto <D.24641>;
      <D.24640>:
      if (0 != 0) goto <D.24642>; else goto <D.24643>;
      <D.24642>:
      monoeg_g_log (0B, 4, "No vtable supported in g_thread_init");
      <D.23549>:
      goto <D.23549>;
      <D.24643>:
      <D.24641>:
      monoeg_g_log_set_always_fatal (4);
      monoeg_g_log_set_fatal_mask (0B, 4);
      opt = parse_optimizations (0B);
      i = 1;
      goto <D.24126>;
      <D.24125>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.24648 = *D.24647;
      if (D.24648 != 45) goto <D.23550>; else goto <D.24649>;
      <D.24649>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.24651>; else goto <D.24652>;
        <D.24651>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24653 = "--regression";
          D.24654 = MEM[(const unsigned char *)D.24653];
          D.24655 = (int) D.24654;
          D.24656 = *__s2;
          D.24657 = (int) D.24656;
          __result = D.24655 - D.24657;
          {
            D.24658 = __s2_len != 0;
            D.24659 = __result == 0;
            D.24660 = D.24658 & D.24659;
            if (D.24660 != 0) goto <D.24661>; else goto <D.24662>;
            <D.24661>:
            D.24663 = &MEM[(void *)"--regression" + 1B];
            D.24664 = *D.24663;
            D.24665 = (int) D.24664;
            D.24666 = __s2 + 1;
            D.24667 = *D.24666;
            D.24668 = (int) D.24667;
            __result = D.24665 - D.24668;
            D.24669 = __s2_len > 1;
            D.24659 = __result == 0;
            D.24670 = D.24669 & D.24659;
            if (D.24670 != 0) goto <D.24671>; else goto <D.24672>;
            <D.24671>:
            D.24673 = &MEM[(void *)"--regression" + 2B];
            D.24674 = *D.24673;
            D.24675 = (int) D.24674;
            D.24676 = __s2 + 2;
            D.24677 = *D.24676;
            D.24678 = (int) D.24677;
            __result = D.24675 - D.24678;
            D.24679 = __s2_len > 2;
            D.24659 = __result == 0;
            D.24680 = D.24679 & D.24659;
            if (D.24680 != 0) goto <D.24681>; else goto <D.24682>;
            <D.24681>:
            D.24683 = &MEM[(void *)"--regression" + 3B];
            D.24684 = *D.24683;
            D.24685 = (int) D.24684;
            D.24686 = __s2 + 3;
            D.24687 = *D.24686;
            D.24688 = (int) D.24687;
            __result = D.24685 - D.24688;
            <D.24682>:
            <D.24672>:
            <D.24662>:
          }
          D.23558 = __result;
        }
        iftmp.20 = -D.23558;
        goto <D.24689>;
        <D.24652>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.20 = __builtin_strcmp (D.24647, "--regression");
        <D.24689>:
        D.23559 = iftmp.20;
      }
      if (D.23559 == 0) goto <D.24690>; else goto <D.24691>;
      <D.24690>:
      action = 1;
      goto <D.24692>;
      <D.24691>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.24693 = strncmp (D.24647, "--single-method=", 16);
      if (D.24693 == 0) goto <D.24694>; else goto <D.24695>;
      <D.24694>:
      {
        char * full_opts;

        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.24696 = D.24647 + 16;
        full_opts = monoeg_g_strdup_printf ("-all,%s", D.24696);
        action = 2;
        mono_single_method_regression_opt.21 = parse_optimizations (full_opts);
        mono_single_method_regression_opt = mono_single_method_regression_opt.21;
        monoeg_g_free (full_opts);
      }
      goto <D.24698>;
      <D.24695>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 9;
        if (__s2_len <= 3) goto <D.24703>; else goto <D.24704>;
        <D.24703>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24705 = "--verbose";
          D.24706 = MEM[(const unsigned char *)D.24705];
          D.24707 = (int) D.24706;
          D.24708 = *__s2;
          D.24709 = (int) D.24708;
          __result = D.24707 - D.24709;
          {
            D.24710 = __s2_len != 0;
            D.24711 = __result == 0;
            D.24712 = D.24710 & D.24711;
            if (D.24712 != 0) goto <D.24713>; else goto <D.24714>;
            <D.24713>:
            D.24715 = &MEM[(void *)"--verbose" + 1B];
            D.24716 = *D.24715;
            D.24717 = (int) D.24716;
            D.24718 = __s2 + 1;
            D.24719 = *D.24718;
            D.24720 = (int) D.24719;
            __result = D.24717 - D.24720;
            D.24721 = __s2_len > 1;
            D.24711 = __result == 0;
            D.24722 = D.24721 & D.24711;
            if (D.24722 != 0) goto <D.24723>; else goto <D.24724>;
            <D.24723>:
            D.24725 = &MEM[(void *)"--verbose" + 2B];
            D.24726 = *D.24725;
            D.24727 = (int) D.24726;
            D.24728 = __s2 + 2;
            D.24729 = *D.24728;
            D.24730 = (int) D.24729;
            __result = D.24727 - D.24730;
            D.24731 = __s2_len > 2;
            D.24711 = __result == 0;
            D.24732 = D.24731 & D.24711;
            if (D.24732 != 0) goto <D.24733>; else goto <D.24734>;
            <D.24733>:
            D.24735 = &MEM[(void *)"--verbose" + 3B];
            D.24736 = *D.24735;
            D.24737 = (int) D.24736;
            D.24738 = __s2 + 3;
            D.24739 = *D.24738;
            D.24740 = (int) D.24739;
            __result = D.24737 - D.24740;
            <D.24734>:
            <D.24724>:
            <D.24714>:
          }
          D.23577 = __result;
        }
        iftmp.22 = -D.23577;
        goto <D.24741>;
        <D.24704>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.22 = __builtin_strcmp (D.24647, "--verbose");
        <D.24741>:
        D.23578 = iftmp.22;
      }
      if (D.23578 == 0) goto <D.24699>; else goto <D.24742>;
      <D.24742>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 2;
        if (__s2_len <= 3) goto <D.24744>; else goto <D.24745>;
        <D.24744>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24746 = "-v";
          D.24747 = MEM[(const unsigned char *)D.24746];
          D.24748 = (int) D.24747;
          D.24749 = *__s2;
          D.24750 = (int) D.24749;
          __result = D.24748 - D.24750;
          {
            D.24751 = __s2_len != 0;
            D.24752 = __result == 0;
            D.24753 = D.24751 & D.24752;
            if (D.24753 != 0) goto <D.24754>; else goto <D.24755>;
            <D.24754>:
            D.24756 = &MEM[(void *)"-v" + 1B];
            D.24757 = *D.24756;
            D.24758 = (int) D.24757;
            D.24759 = __s2 + 1;
            D.24760 = *D.24759;
            D.24761 = (int) D.24760;
            __result = D.24758 - D.24761;
            D.24762 = __s2_len > 1;
            D.24752 = __result == 0;
            D.24763 = D.24762 & D.24752;
            if (D.24763 != 0) goto <D.24764>; else goto <D.24765>;
            <D.24764>:
            D.24766 = &MEM[(void *)"-v" + 2B];
            D.24767 = *D.24766;
            D.24768 = (int) D.24767;
            D.24769 = __s2 + 2;
            D.24770 = *D.24769;
            D.24771 = (int) D.24770;
            __result = D.24768 - D.24771;
            D.24772 = __s2_len > 2;
            D.24752 = __result == 0;
            D.24773 = D.24772 & D.24752;
            if (D.24773 != 0) goto <D.24774>; else goto <D.24775>;
            <D.24774>:
            D.24776 = &MEM[(void *)"-v" + 3B];
            D.24777 = *D.24776;
            D.24778 = (int) D.24777;
            D.24779 = __s2 + 3;
            D.24780 = *D.24779;
            D.24781 = (int) D.24780;
            __result = D.24778 - D.24781;
            <D.24775>:
            <D.24765>:
            <D.24755>:
          }
          D.23586 = __result;
        }
        iftmp.23 = -D.23586;
        goto <D.24782>;
        <D.24745>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.23 = __builtin_strcmp (D.24647, "-v");
        <D.24782>:
        D.23587 = iftmp.23;
      }
      if (D.23587 == 0) goto <D.24699>; else goto <D.24700>;
      <D.24699>:
      mini_verbose = mini_verbose + 1;
      goto <D.24701>;
      <D.24700>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 9;
        if (__s2_len <= 3) goto <D.24786>; else goto <D.24787>;
        <D.24786>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24788 = "--version";
          D.24789 = MEM[(const unsigned char *)D.24788];
          D.24790 = (int) D.24789;
          D.24791 = *__s2;
          D.24792 = (int) D.24791;
          __result = D.24790 - D.24792;
          {
            D.24793 = __s2_len != 0;
            D.24794 = __result == 0;
            D.24795 = D.24793 & D.24794;
            if (D.24795 != 0) goto <D.24796>; else goto <D.24797>;
            <D.24796>:
            D.24798 = &MEM[(void *)"--version" + 1B];
            D.24799 = *D.24798;
            D.24800 = (int) D.24799;
            D.24801 = __s2 + 1;
            D.24802 = *D.24801;
            D.24803 = (int) D.24802;
            __result = D.24800 - D.24803;
            D.24804 = __s2_len > 1;
            D.24794 = __result == 0;
            D.24805 = D.24804 & D.24794;
            if (D.24805 != 0) goto <D.24806>; else goto <D.24807>;
            <D.24806>:
            D.24808 = &MEM[(void *)"--version" + 2B];
            D.24809 = *D.24808;
            D.24810 = (int) D.24809;
            D.24811 = __s2 + 2;
            D.24812 = *D.24811;
            D.24813 = (int) D.24812;
            __result = D.24810 - D.24813;
            D.24814 = __s2_len > 2;
            D.24794 = __result == 0;
            D.24815 = D.24814 & D.24794;
            if (D.24815 != 0) goto <D.24816>; else goto <D.24817>;
            <D.24816>:
            D.24818 = &MEM[(void *)"--version" + 3B];
            D.24819 = *D.24818;
            D.24820 = (int) D.24819;
            D.24821 = __s2 + 3;
            D.24822 = *D.24821;
            D.24823 = (int) D.24822;
            __result = D.24820 - D.24823;
            <D.24817>:
            <D.24807>:
            <D.24797>:
          }
          D.23595 = __result;
        }
        iftmp.24 = -D.23595;
        goto <D.24824>;
        <D.24787>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.24 = __builtin_strcmp (D.24647, "--version");
        <D.24824>:
        D.23596 = iftmp.24;
      }
      if (D.23596 == 0) goto <D.24783>; else goto <D.24825>;
      <D.24825>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 2;
        if (__s2_len <= 3) goto <D.24827>; else goto <D.24828>;
        <D.24827>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24829 = "-V";
          D.24830 = MEM[(const unsigned char *)D.24829];
          D.24831 = (int) D.24830;
          D.24832 = *__s2;
          D.24833 = (int) D.24832;
          __result = D.24831 - D.24833;
          {
            D.24834 = __s2_len != 0;
            D.24835 = __result == 0;
            D.24836 = D.24834 & D.24835;
            if (D.24836 != 0) goto <D.24837>; else goto <D.24838>;
            <D.24837>:
            D.24839 = &MEM[(void *)"-V" + 1B];
            D.24840 = *D.24839;
            D.24841 = (int) D.24840;
            D.24842 = __s2 + 1;
            D.24843 = *D.24842;
            D.24844 = (int) D.24843;
            __result = D.24841 - D.24844;
            D.24845 = __s2_len > 1;
            D.24835 = __result == 0;
            D.24846 = D.24845 & D.24835;
            if (D.24846 != 0) goto <D.24847>; else goto <D.24848>;
            <D.24847>:
            D.24849 = &MEM[(void *)"-V" + 2B];
            D.24850 = *D.24849;
            D.24851 = (int) D.24850;
            D.24852 = __s2 + 2;
            D.24853 = *D.24852;
            D.24854 = (int) D.24853;
            __result = D.24851 - D.24854;
            D.24855 = __s2_len > 2;
            D.24835 = __result == 0;
            D.24856 = D.24855 & D.24835;
            if (D.24856 != 0) goto <D.24857>; else goto <D.24858>;
            <D.24857>:
            D.24859 = &MEM[(void *)"-V" + 3B];
            D.24860 = *D.24859;
            D.24861 = (int) D.24860;
            D.24862 = __s2 + 3;
            D.24863 = *D.24862;
            D.24864 = (int) D.24863;
            __result = D.24861 - D.24864;
            <D.24858>:
            <D.24848>:
            <D.24838>:
          }
          D.23604 = __result;
        }
        iftmp.25 = -D.23604;
        goto <D.24865>;
        <D.24828>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.25 = __builtin_strcmp (D.24647, "-V");
        <D.24865>:
        D.23605 = iftmp.25;
      }
      if (D.23605 == 0) goto <D.24783>; else goto <D.24784>;
      <D.24783>:
      {
        char * build;
        char * gc_descr;

        build = mono_get_runtime_build_info ();
        monoeg_g_print ("Mono JIT compiler version %s\nCopyright (C) 2002-2014 Novell, Inc, Xamarin Inc and Contributors. www.mono-project.com\n", build);
        monoeg_g_free (build);
        monoeg_g_print (&info);
        gc_descr = mono_gc_get_description ();
        monoeg_g_print ("\tGC:            %s\n", gc_descr);
        monoeg_g_free (gc_descr);
        if (mini_verbose != 0) goto <D.24866>; else goto <D.24867>;
        <D.24866>:
        {
          const char * cerror;
          const char * clibpath;

          mono_init ("mono");
          cerror = mono_check_corlib_version ();
          D.24869 = mono_defaults.corlib;
          if (D.24869 != 0B) goto <D.24870>; else goto <D.24871>;
          <D.24870>:
          D.24869 = mono_defaults.corlib;
          iftmp.26 = mono_image_get_filename (D.24869);
          goto <D.24872>;
          <D.24871>:
          iftmp.26 = "unknown";
          <D.24872>:
          clibpath = iftmp.26;
          if (cerror != 0B) goto <D.24873>; else goto <D.24874>;
          <D.24873>:
          monoeg_g_print ("The currently installed mscorlib doesn\'t match this runtime version.\n");
          monoeg_g_print ("The error is: %s\n", cerror);
          monoeg_g_print ("mscorlib.dll loaded at: %s\n", clibpath);
          D.24875 = 1;
          return D.24875;
          <D.24874>:
        }
        <D.24867>:
        D.24875 = 0;
        return D.24875;
      }
      <D.24784>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.24879>; else goto <D.24880>;
        <D.24879>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24881 = "--help";
          D.24882 = MEM[(const unsigned char *)D.24881];
          D.24883 = (int) D.24882;
          D.24884 = *__s2;
          D.24885 = (int) D.24884;
          __result = D.24883 - D.24885;
          {
            D.24886 = __s2_len != 0;
            D.24887 = __result == 0;
            D.24888 = D.24886 & D.24887;
            if (D.24888 != 0) goto <D.24889>; else goto <D.24890>;
            <D.24889>:
            D.24891 = &MEM[(void *)"--help" + 1B];
            D.24892 = *D.24891;
            D.24893 = (int) D.24892;
            D.24894 = __s2 + 1;
            D.24895 = *D.24894;
            D.24896 = (int) D.24895;
            __result = D.24893 - D.24896;
            D.24897 = __s2_len > 1;
            D.24887 = __result == 0;
            D.24898 = D.24897 & D.24887;
            if (D.24898 != 0) goto <D.24899>; else goto <D.24900>;
            <D.24899>:
            D.24901 = &MEM[(void *)"--help" + 2B];
            D.24902 = *D.24901;
            D.24903 = (int) D.24902;
            D.24904 = __s2 + 2;
            D.24905 = *D.24904;
            D.24906 = (int) D.24905;
            __result = D.24903 - D.24906;
            D.24907 = __s2_len > 2;
            D.24887 = __result == 0;
            D.24908 = D.24907 & D.24887;
            if (D.24908 != 0) goto <D.24909>; else goto <D.24910>;
            <D.24909>:
            D.24911 = &MEM[(void *)"--help" + 3B];
            D.24912 = *D.24911;
            D.24913 = (int) D.24912;
            D.24914 = __s2 + 3;
            D.24915 = *D.24914;
            D.24916 = (int) D.24915;
            __result = D.24913 - D.24916;
            <D.24910>:
            <D.24900>:
            <D.24890>:
          }
          D.23617 = __result;
        }
        iftmp.27 = -D.23617;
        goto <D.24917>;
        <D.24880>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.27 = __builtin_strcmp (D.24647, "--help");
        <D.24917>:
        D.23618 = iftmp.27;
      }
      if (D.23618 == 0) goto <D.24876>; else goto <D.24918>;
      <D.24918>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 2;
        if (__s2_len <= 3) goto <D.24920>; else goto <D.24921>;
        <D.24920>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24922 = "-h";
          D.24923 = MEM[(const unsigned char *)D.24922];
          D.24924 = (int) D.24923;
          D.24925 = *__s2;
          D.24926 = (int) D.24925;
          __result = D.24924 - D.24926;
          {
            D.24927 = __s2_len != 0;
            D.24928 = __result == 0;
            D.24929 = D.24927 & D.24928;
            if (D.24929 != 0) goto <D.24930>; else goto <D.24931>;
            <D.24930>:
            D.24932 = &MEM[(void *)"-h" + 1B];
            D.24933 = *D.24932;
            D.24934 = (int) D.24933;
            D.24935 = __s2 + 1;
            D.24936 = *D.24935;
            D.24937 = (int) D.24936;
            __result = D.24934 - D.24937;
            D.24938 = __s2_len > 1;
            D.24928 = __result == 0;
            D.24939 = D.24938 & D.24928;
            if (D.24939 != 0) goto <D.24940>; else goto <D.24941>;
            <D.24940>:
            D.24942 = &MEM[(void *)"-h" + 2B];
            D.24943 = *D.24942;
            D.24944 = (int) D.24943;
            D.24945 = __s2 + 2;
            D.24946 = *D.24945;
            D.24947 = (int) D.24946;
            __result = D.24944 - D.24947;
            D.24948 = __s2_len > 2;
            D.24928 = __result == 0;
            D.24949 = D.24948 & D.24928;
            if (D.24949 != 0) goto <D.24950>; else goto <D.24951>;
            <D.24950>:
            D.24952 = &MEM[(void *)"-h" + 3B];
            D.24953 = *D.24952;
            D.24954 = (int) D.24953;
            D.24955 = __s2 + 3;
            D.24956 = *D.24955;
            D.24957 = (int) D.24956;
            __result = D.24954 - D.24957;
            <D.24951>:
            <D.24941>:
            <D.24931>:
          }
          D.23626 = __result;
        }
        iftmp.28 = -D.23626;
        goto <D.24958>;
        <D.24921>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.28 = __builtin_strcmp (D.24647, "-h");
        <D.24958>:
        D.23627 = iftmp.28;
      }
      if (D.23627 == 0) goto <D.24876>; else goto <D.24877>;
      <D.24876>:
      mini_usage ();
      D.24875 = 0;
      return D.24875;
      <D.24877>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.24960>; else goto <D.24961>;
        <D.24960>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.24962 = "--help-trace";
          D.24963 = MEM[(const unsigned char *)D.24962];
          D.24964 = (int) D.24963;
          D.24965 = *__s2;
          D.24966 = (int) D.24965;
          __result = D.24964 - D.24966;
          {
            D.24967 = __s2_len != 0;
            D.24968 = __result == 0;
            D.24969 = D.24967 & D.24968;
            if (D.24969 != 0) goto <D.24970>; else goto <D.24971>;
            <D.24970>:
            D.24972 = &MEM[(void *)"--help-trace" + 1B];
            D.24973 = *D.24972;
            D.24974 = (int) D.24973;
            D.24975 = __s2 + 1;
            D.24976 = *D.24975;
            D.24977 = (int) D.24976;
            __result = D.24974 - D.24977;
            D.24978 = __s2_len > 1;
            D.24968 = __result == 0;
            D.24979 = D.24978 & D.24968;
            if (D.24979 != 0) goto <D.24980>; else goto <D.24981>;
            <D.24980>:
            D.24982 = &MEM[(void *)"--help-trace" + 2B];
            D.24983 = *D.24982;
            D.24984 = (int) D.24983;
            D.24985 = __s2 + 2;
            D.24986 = *D.24985;
            D.24987 = (int) D.24986;
            __result = D.24984 - D.24987;
            D.24988 = __s2_len > 2;
            D.24968 = __result == 0;
            D.24989 = D.24988 & D.24968;
            if (D.24989 != 0) goto <D.24990>; else goto <D.24991>;
            <D.24990>:
            D.24992 = &MEM[(void *)"--help-trace" + 3B];
            D.24993 = *D.24992;
            D.24994 = (int) D.24993;
            D.24995 = __s2 + 3;
            D.24996 = *D.24995;
            D.24997 = (int) D.24996;
            __result = D.24994 - D.24997;
            <D.24991>:
            <D.24981>:
            <D.24971>:
          }
          D.23635 = __result;
        }
        iftmp.29 = -D.23635;
        goto <D.24998>;
        <D.24961>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.29 = __builtin_strcmp (D.24647, "--help-trace");
        <D.24998>:
        D.23636 = iftmp.29;
      }
      if (D.23636 == 0) goto <D.24999>; else goto <D.25000>;
      <D.24999>:
      mini_trace_usage ();
      D.24875 = 0;
      return D.24875;
      <D.25000>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.25002>; else goto <D.25003>;
        <D.25002>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25004 = "--help-devel";
          D.25005 = MEM[(const unsigned char *)D.25004];
          D.25006 = (int) D.25005;
          D.25007 = *__s2;
          D.25008 = (int) D.25007;
          __result = D.25006 - D.25008;
          {
            D.25009 = __s2_len != 0;
            D.25010 = __result == 0;
            D.25011 = D.25009 & D.25010;
            if (D.25011 != 0) goto <D.25012>; else goto <D.25013>;
            <D.25012>:
            D.25014 = &MEM[(void *)"--help-devel" + 1B];
            D.25015 = *D.25014;
            D.25016 = (int) D.25015;
            D.25017 = __s2 + 1;
            D.25018 = *D.25017;
            D.25019 = (int) D.25018;
            __result = D.25016 - D.25019;
            D.25020 = __s2_len > 1;
            D.25010 = __result == 0;
            D.25021 = D.25020 & D.25010;
            if (D.25021 != 0) goto <D.25022>; else goto <D.25023>;
            <D.25022>:
            D.25024 = &MEM[(void *)"--help-devel" + 2B];
            D.25025 = *D.25024;
            D.25026 = (int) D.25025;
            D.25027 = __s2 + 2;
            D.25028 = *D.25027;
            D.25029 = (int) D.25028;
            __result = D.25026 - D.25029;
            D.25030 = __s2_len > 2;
            D.25010 = __result == 0;
            D.25031 = D.25030 & D.25010;
            if (D.25031 != 0) goto <D.25032>; else goto <D.25033>;
            <D.25032>:
            D.25034 = &MEM[(void *)"--help-devel" + 3B];
            D.25035 = *D.25034;
            D.25036 = (int) D.25035;
            D.25037 = __s2 + 3;
            D.25038 = *D.25037;
            D.25039 = (int) D.25038;
            __result = D.25036 - D.25039;
            <D.25033>:
            <D.25023>:
            <D.25013>:
          }
          D.23644 = __result;
        }
        iftmp.30 = -D.23644;
        goto <D.25040>;
        <D.25003>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.30 = __builtin_strcmp (D.24647, "--help-devel");
        <D.25040>:
        D.23645 = iftmp.30;
      }
      if (D.23645 == 0) goto <D.25041>; else goto <D.25042>;
      <D.25041>:
      mini_usage_jitdeveloper ();
      D.24875 = 0;
      return D.24875;
      <D.25042>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.25044>; else goto <D.25045>;
        <D.25044>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25046 = "--help-debug";
          D.25047 = MEM[(const unsigned char *)D.25046];
          D.25048 = (int) D.25047;
          D.25049 = *__s2;
          D.25050 = (int) D.25049;
          __result = D.25048 - D.25050;
          {
            D.25051 = __s2_len != 0;
            D.25052 = __result == 0;
            D.25053 = D.25051 & D.25052;
            if (D.25053 != 0) goto <D.25054>; else goto <D.25055>;
            <D.25054>:
            D.25056 = &MEM[(void *)"--help-debug" + 1B];
            D.25057 = *D.25056;
            D.25058 = (int) D.25057;
            D.25059 = __s2 + 1;
            D.25060 = *D.25059;
            D.25061 = (int) D.25060;
            __result = D.25058 - D.25061;
            D.25062 = __s2_len > 1;
            D.25052 = __result == 0;
            D.25063 = D.25062 & D.25052;
            if (D.25063 != 0) goto <D.25064>; else goto <D.25065>;
            <D.25064>:
            D.25066 = &MEM[(void *)"--help-debug" + 2B];
            D.25067 = *D.25066;
            D.25068 = (int) D.25067;
            D.25069 = __s2 + 2;
            D.25070 = *D.25069;
            D.25071 = (int) D.25070;
            __result = D.25068 - D.25071;
            D.25072 = __s2_len > 2;
            D.25052 = __result == 0;
            D.25073 = D.25072 & D.25052;
            if (D.25073 != 0) goto <D.25074>; else goto <D.25075>;
            <D.25074>:
            D.25076 = &MEM[(void *)"--help-debug" + 3B];
            D.25077 = *D.25076;
            D.25078 = (int) D.25077;
            D.25079 = __s2 + 3;
            D.25080 = *D.25079;
            D.25081 = (int) D.25080;
            __result = D.25078 - D.25081;
            <D.25075>:
            <D.25065>:
            <D.25055>:
          }
          D.23653 = __result;
        }
        iftmp.31 = -D.23653;
        goto <D.25082>;
        <D.25045>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.31 = __builtin_strcmp (D.24647, "--help-debug");
        <D.25082>:
        D.23654 = iftmp.31;
      }
      if (D.23654 == 0) goto <D.25083>; else goto <D.25084>;
      <D.25083>:
      mini_debug_usage ();
      D.24875 = 0;
      return D.24875;
      <D.25084>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 10;
        if (__s2_len <= 3) goto <D.25086>; else goto <D.25087>;
        <D.25086>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25088 = "--list-opt";
          D.25089 = MEM[(const unsigned char *)D.25088];
          D.25090 = (int) D.25089;
          D.25091 = *__s2;
          D.25092 = (int) D.25091;
          __result = D.25090 - D.25092;
          {
            D.25093 = __s2_len != 0;
            D.25094 = __result == 0;
            D.25095 = D.25093 & D.25094;
            if (D.25095 != 0) goto <D.25096>; else goto <D.25097>;
            <D.25096>:
            D.25098 = &MEM[(void *)"--list-opt" + 1B];
            D.25099 = *D.25098;
            D.25100 = (int) D.25099;
            D.25101 = __s2 + 1;
            D.25102 = *D.25101;
            D.25103 = (int) D.25102;
            __result = D.25100 - D.25103;
            D.25104 = __s2_len > 1;
            D.25094 = __result == 0;
            D.25105 = D.25104 & D.25094;
            if (D.25105 != 0) goto <D.25106>; else goto <D.25107>;
            <D.25106>:
            D.25108 = &MEM[(void *)"--list-opt" + 2B];
            D.25109 = *D.25108;
            D.25110 = (int) D.25109;
            D.25111 = __s2 + 2;
            D.25112 = *D.25111;
            D.25113 = (int) D.25112;
            __result = D.25110 - D.25113;
            D.25114 = __s2_len > 2;
            D.25094 = __result == 0;
            D.25115 = D.25114 & D.25094;
            if (D.25115 != 0) goto <D.25116>; else goto <D.25117>;
            <D.25116>:
            D.25118 = &MEM[(void *)"--list-opt" + 3B];
            D.25119 = *D.25118;
            D.25120 = (int) D.25119;
            D.25121 = __s2 + 3;
            D.25122 = *D.25121;
            D.25123 = (int) D.25122;
            __result = D.25120 - D.25123;
            <D.25117>:
            <D.25107>:
            <D.25097>:
          }
          D.23662 = __result;
        }
        iftmp.32 = -D.23662;
        goto <D.25124>;
        <D.25087>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.32 = __builtin_strcmp (D.24647, "--list-opt");
        <D.25124>:
        D.23663 = iftmp.32;
      }
      if (D.23663 == 0) goto <D.25125>; else goto <D.25126>;
      <D.25125>:
      mini_usage_list_opt ();
      D.24875 = 0;
      return D.24875;
      <D.25126>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25127 = strncmp (D.24647, "--statfile", 10);
      if (D.25127 == 0) goto <D.25128>; else goto <D.25129>;
      <D.25128>:
      D.25130 = i + 1;
      if (D.25130 >= argc) goto <D.25131>; else goto <D.25132>;
      <D.25131>:
      stderr.33 = stderr;
      fprintf (stderr.33, "error: --statfile requires a filename argument\n");
      D.24875 = 1;
      return D.24875;
      <D.25132>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      mini_stats_fd.34 = fopen (D.24647, "w+");
      mini_stats_fd = mini_stats_fd.34;
      goto <D.25135>;
      <D.25129>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25136 = strncmp (D.24647, "--optimize=", 11);
      if (D.25136 == 0) goto <D.25137>; else goto <D.25138>;
      <D.25137>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25139 = D.24647 + 11;
      opt = parse_optimizations (D.25139);
      goto <D.25140>;
      <D.25138>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25141 = strncmp (D.24647, "-O=", 3);
      if (D.25141 == 0) goto <D.25142>; else goto <D.25143>;
      <D.25142>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25144 = D.24647 + 3;
      opt = parse_optimizations (D.25144);
      goto <D.25145>;
      <D.25143>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 9;
        if (__s2_len <= 3) goto <D.25147>; else goto <D.25148>;
        <D.25147>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25149 = "--gc=sgen";
          D.25150 = MEM[(const unsigned char *)D.25149];
          D.25151 = (int) D.25150;
          D.25152 = *__s2;
          D.25153 = (int) D.25152;
          __result = D.25151 - D.25153;
          {
            D.25154 = __s2_len != 0;
            D.25155 = __result == 0;
            D.25156 = D.25154 & D.25155;
            if (D.25156 != 0) goto <D.25157>; else goto <D.25158>;
            <D.25157>:
            D.25159 = &MEM[(void *)"--gc=sgen" + 1B];
            D.25160 = *D.25159;
            D.25161 = (int) D.25160;
            D.25162 = __s2 + 1;
            D.25163 = *D.25162;
            D.25164 = (int) D.25163;
            __result = D.25161 - D.25164;
            D.25165 = __s2_len > 1;
            D.25155 = __result == 0;
            D.25166 = D.25165 & D.25155;
            if (D.25166 != 0) goto <D.25167>; else goto <D.25168>;
            <D.25167>:
            D.25169 = &MEM[(void *)"--gc=sgen" + 2B];
            D.25170 = *D.25169;
            D.25171 = (int) D.25170;
            D.25172 = __s2 + 2;
            D.25173 = *D.25172;
            D.25174 = (int) D.25173;
            __result = D.25171 - D.25174;
            D.25175 = __s2_len > 2;
            D.25155 = __result == 0;
            D.25176 = D.25175 & D.25155;
            if (D.25176 != 0) goto <D.25177>; else goto <D.25178>;
            <D.25177>:
            D.25179 = &MEM[(void *)"--gc=sgen" + 3B];
            D.25180 = *D.25179;
            D.25181 = (int) D.25180;
            D.25182 = __s2 + 3;
            D.25183 = *D.25182;
            D.25184 = (int) D.25183;
            __result = D.25181 - D.25184;
            <D.25178>:
            <D.25168>:
            <D.25158>:
          }
          D.23698 = __result;
        }
        iftmp.35 = -D.23698;
        goto <D.25185>;
        <D.25148>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.35 = __builtin_strcmp (D.24647, "--gc=sgen");
        <D.25185>:
        D.23699 = iftmp.35;
      }
      if (D.23699 == 0) goto <D.25186>; else goto <D.25187>;
      <D.25186>:
      switch_gc (argv, "sgen");
      goto <D.25188>;
      <D.25187>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 10;
        if (__s2_len <= 3) goto <D.25190>; else goto <D.25191>;
        <D.25190>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25192 = "--gc=boehm";
          D.25193 = MEM[(const unsigned char *)D.25192];
          D.25194 = (int) D.25193;
          D.25195 = *__s2;
          D.25196 = (int) D.25195;
          __result = D.25194 - D.25196;
          {
            D.25197 = __s2_len != 0;
            D.25198 = __result == 0;
            D.25199 = D.25197 & D.25198;
            if (D.25199 != 0) goto <D.25200>; else goto <D.25201>;
            <D.25200>:
            D.25202 = &MEM[(void *)"--gc=boehm" + 1B];
            D.25203 = *D.25202;
            D.25204 = (int) D.25203;
            D.25205 = __s2 + 1;
            D.25206 = *D.25205;
            D.25207 = (int) D.25206;
            __result = D.25204 - D.25207;
            D.25208 = __s2_len > 1;
            D.25198 = __result == 0;
            D.25209 = D.25208 & D.25198;
            if (D.25209 != 0) goto <D.25210>; else goto <D.25211>;
            <D.25210>:
            D.25212 = &MEM[(void *)"--gc=boehm" + 2B];
            D.25213 = *D.25212;
            D.25214 = (int) D.25213;
            D.25215 = __s2 + 2;
            D.25216 = *D.25215;
            D.25217 = (int) D.25216;
            __result = D.25214 - D.25217;
            D.25218 = __s2_len > 2;
            D.25198 = __result == 0;
            D.25219 = D.25218 & D.25198;
            if (D.25219 != 0) goto <D.25220>; else goto <D.25221>;
            <D.25220>:
            D.25222 = &MEM[(void *)"--gc=boehm" + 3B];
            D.25223 = *D.25222;
            D.25224 = (int) D.25223;
            D.25225 = __s2 + 3;
            D.25226 = *D.25225;
            D.25227 = (int) D.25226;
            __result = D.25224 - D.25227;
            <D.25221>:
            <D.25211>:
            <D.25201>:
          }
          D.23707 = __result;
        }
        iftmp.36 = -D.23707;
        goto <D.25228>;
        <D.25191>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.36 = __builtin_strcmp (D.24647, "--gc=boehm");
        <D.25228>:
        D.23708 = iftmp.36;
      }
      if (D.23708 == 0) goto <D.25229>; else goto <D.25230>;
      <D.25229>:
      switch_gc (argv, "boehm");
      goto <D.25231>;
      <D.25230>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.25233>; else goto <D.25234>;
        <D.25233>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25235 = "--config";
          D.25236 = MEM[(const unsigned char *)D.25235];
          D.25237 = (int) D.25236;
          D.25238 = *__s2;
          D.25239 = (int) D.25238;
          __result = D.25237 - D.25239;
          {
            D.25240 = __s2_len != 0;
            D.25241 = __result == 0;
            D.25242 = D.25240 & D.25241;
            if (D.25242 != 0) goto <D.25243>; else goto <D.25244>;
            <D.25243>:
            D.25245 = &MEM[(void *)"--config" + 1B];
            D.25246 = *D.25245;
            D.25247 = (int) D.25246;
            D.25248 = __s2 + 1;
            D.25249 = *D.25248;
            D.25250 = (int) D.25249;
            __result = D.25247 - D.25250;
            D.25251 = __s2_len > 1;
            D.25241 = __result == 0;
            D.25252 = D.25251 & D.25241;
            if (D.25252 != 0) goto <D.25253>; else goto <D.25254>;
            <D.25253>:
            D.25255 = &MEM[(void *)"--config" + 2B];
            D.25256 = *D.25255;
            D.25257 = (int) D.25256;
            D.25258 = __s2 + 2;
            D.25259 = *D.25258;
            D.25260 = (int) D.25259;
            __result = D.25257 - D.25260;
            D.25261 = __s2_len > 2;
            D.25241 = __result == 0;
            D.25262 = D.25261 & D.25241;
            if (D.25262 != 0) goto <D.25263>; else goto <D.25264>;
            <D.25263>:
            D.25265 = &MEM[(void *)"--config" + 3B];
            D.25266 = *D.25265;
            D.25267 = (int) D.25266;
            D.25268 = __s2 + 3;
            D.25269 = *D.25268;
            D.25270 = (int) D.25269;
            __result = D.25267 - D.25270;
            <D.25264>:
            <D.25254>:
            <D.25244>:
          }
          D.23716 = __result;
        }
        iftmp.37 = -D.23716;
        goto <D.25271>;
        <D.25234>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.37 = __builtin_strcmp (D.24647, "--config");
        <D.25271>:
        D.23717 = iftmp.37;
      }
      if (D.23717 == 0) goto <D.25272>; else goto <D.25273>;
      <D.25272>:
      D.25130 = i + 1;
      if (D.25130 >= argc) goto <D.25274>; else goto <D.25275>;
      <D.25274>:
      stderr.33 = stderr;
      fprintf (stderr.33, "error: --config requires a filename argument\n");
      D.24875 = 1;
      return D.24875;
      <D.25275>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      config_file = *D.24646;
      goto <D.25276>;
      <D.25273>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 10;
        if (__s2_len <= 3) goto <D.25278>; else goto <D.25279>;
        <D.25278>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25280 = "--ncompile";
          D.25281 = MEM[(const unsigned char *)D.25280];
          D.25282 = (int) D.25281;
          D.25283 = *__s2;
          D.25284 = (int) D.25283;
          __result = D.25282 - D.25284;
          {
            D.25285 = __s2_len != 0;
            D.25286 = __result == 0;
            D.25287 = D.25285 & D.25286;
            if (D.25287 != 0) goto <D.25288>; else goto <D.25289>;
            <D.25288>:
            D.25290 = &MEM[(void *)"--ncompile" + 1B];
            D.25291 = *D.25290;
            D.25292 = (int) D.25291;
            D.25293 = __s2 + 1;
            D.25294 = *D.25293;
            D.25295 = (int) D.25294;
            __result = D.25292 - D.25295;
            D.25296 = __s2_len > 1;
            D.25286 = __result == 0;
            D.25297 = D.25296 & D.25286;
            if (D.25297 != 0) goto <D.25298>; else goto <D.25299>;
            <D.25298>:
            D.25300 = &MEM[(void *)"--ncompile" + 2B];
            D.25301 = *D.25300;
            D.25302 = (int) D.25301;
            D.25303 = __s2 + 2;
            D.25304 = *D.25303;
            D.25305 = (int) D.25304;
            __result = D.25302 - D.25305;
            D.25306 = __s2_len > 2;
            D.25286 = __result == 0;
            D.25307 = D.25306 & D.25286;
            if (D.25307 != 0) goto <D.25308>; else goto <D.25309>;
            <D.25308>:
            D.25310 = &MEM[(void *)"--ncompile" + 3B];
            D.25311 = *D.25310;
            D.25312 = (int) D.25311;
            D.25313 = __s2 + 3;
            D.25314 = *D.25313;
            D.25315 = (int) D.25314;
            __result = D.25312 - D.25315;
            <D.25309>:
            <D.25299>:
            <D.25289>:
          }
          D.23725 = __result;
        }
        iftmp.38 = -D.23725;
        goto <D.25316>;
        <D.25279>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.38 = __builtin_strcmp (D.24647, "--ncompile");
        <D.25316>:
        D.23726 = iftmp.38;
      }
      if (D.23726 == 0) goto <D.25317>; else goto <D.25318>;
      <D.25317>:
      D.25130 = i + 1;
      if (D.25130 >= argc) goto <D.25319>; else goto <D.25320>;
      <D.25319>:
      stderr.33 = stderr;
      fprintf (stderr.33, "error: --ncompile requires an argument\n");
      D.24875 = 1;
      return D.24875;
      <D.25320>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      count = atoi (D.24647);
      action = 0;
      goto <D.25321>;
      <D.25318>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.25323>; else goto <D.25324>;
        <D.25323>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25325 = "--trace";
          D.25326 = MEM[(const unsigned char *)D.25325];
          D.25327 = (int) D.25326;
          D.25328 = *__s2;
          D.25329 = (int) D.25328;
          __result = D.25327 - D.25329;
          {
            D.25330 = __s2_len != 0;
            D.25331 = __result == 0;
            D.25332 = D.25330 & D.25331;
            if (D.25332 != 0) goto <D.25333>; else goto <D.25334>;
            <D.25333>:
            D.25335 = &MEM[(void *)"--trace" + 1B];
            D.25336 = *D.25335;
            D.25337 = (int) D.25336;
            D.25338 = __s2 + 1;
            D.25339 = *D.25338;
            D.25340 = (int) D.25339;
            __result = D.25337 - D.25340;
            D.25341 = __s2_len > 1;
            D.25331 = __result == 0;
            D.25342 = D.25341 & D.25331;
            if (D.25342 != 0) goto <D.25343>; else goto <D.25344>;
            <D.25343>:
            D.25345 = &MEM[(void *)"--trace" + 2B];
            D.25346 = *D.25345;
            D.25347 = (int) D.25346;
            D.25348 = __s2 + 2;
            D.25349 = *D.25348;
            D.25350 = (int) D.25349;
            __result = D.25347 - D.25350;
            D.25351 = __s2_len > 2;
            D.25331 = __result == 0;
            D.25352 = D.25351 & D.25331;
            if (D.25352 != 0) goto <D.25353>; else goto <D.25354>;
            <D.25353>:
            D.25355 = &MEM[(void *)"--trace" + 3B];
            D.25356 = *D.25355;
            D.25357 = (int) D.25356;
            D.25358 = __s2 + 3;
            D.25359 = *D.25358;
            D.25360 = (int) D.25359;
            __result = D.25357 - D.25360;
            <D.25354>:
            <D.25344>:
            <D.25334>:
          }
          D.23734 = __result;
        }
        iftmp.39 = -D.23734;
        goto <D.25361>;
        <D.25324>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.39 = __builtin_strcmp (D.24647, "--trace");
        <D.25361>:
        D.23735 = iftmp.39;
      }
      if (D.23735 == 0) goto <D.25362>; else goto <D.25363>;
      <D.25362>:
      trace_options = "";
      goto <D.25364>;
      <D.25363>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25365 = strncmp (D.24647, "--trace=", 8);
      if (D.25365 == 0) goto <D.25366>; else goto <D.25367>;
      <D.25366>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      trace_options = D.24647 + 8;
      goto <D.25368>;
      <D.25367>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 11;
        if (__s2_len <= 3) goto <D.25370>; else goto <D.25371>;
        <D.25370>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25372 = "--breakonex";
          D.25373 = MEM[(const unsigned char *)D.25372];
          D.25374 = (int) D.25373;
          D.25375 = *__s2;
          D.25376 = (int) D.25375;
          __result = D.25374 - D.25376;
          {
            D.25377 = __s2_len != 0;
            D.25378 = __result == 0;
            D.25379 = D.25377 & D.25378;
            if (D.25379 != 0) goto <D.25380>; else goto <D.25381>;
            <D.25380>:
            D.25382 = &MEM[(void *)"--breakonex" + 1B];
            D.25383 = *D.25382;
            D.25384 = (int) D.25383;
            D.25385 = __s2 + 1;
            D.25386 = *D.25385;
            D.25387 = (int) D.25386;
            __result = D.25384 - D.25387;
            D.25388 = __s2_len > 1;
            D.25378 = __result == 0;
            D.25389 = D.25388 & D.25378;
            if (D.25389 != 0) goto <D.25390>; else goto <D.25391>;
            <D.25390>:
            D.25392 = &MEM[(void *)"--breakonex" + 2B];
            D.25393 = *D.25392;
            D.25394 = (int) D.25393;
            D.25395 = __s2 + 2;
            D.25396 = *D.25395;
            D.25397 = (int) D.25396;
            __result = D.25394 - D.25397;
            D.25398 = __s2_len > 2;
            D.25378 = __result == 0;
            D.25399 = D.25398 & D.25378;
            if (D.25399 != 0) goto <D.25400>; else goto <D.25401>;
            <D.25400>:
            D.25402 = &MEM[(void *)"--breakonex" + 3B];
            D.25403 = *D.25402;
            D.25404 = (int) D.25403;
            D.25405 = __s2 + 3;
            D.25406 = *D.25405;
            D.25407 = (int) D.25406;
            __result = D.25404 - D.25407;
            <D.25401>:
            <D.25391>:
            <D.25381>:
          }
          D.23752 = __result;
        }
        iftmp.40 = -D.23752;
        goto <D.25408>;
        <D.25371>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.40 = __builtin_strcmp (D.24647, "--breakonex");
        <D.25408>:
        D.23753 = iftmp.40;
      }
      if (D.23753 == 0) goto <D.25409>; else goto <D.25410>;
      <D.25409>:
      {
        struct MonoDebugOptions * opt;

        opt = mini_get_debug_options ();
        opt->break_on_exc = 1;
      }
      goto <D.25411>;
      <D.25410>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.25413>; else goto <D.25414>;
        <D.25413>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25415 = "--break";
          D.25416 = MEM[(const unsigned char *)D.25415];
          D.25417 = (int) D.25416;
          D.25418 = *__s2;
          D.25419 = (int) D.25418;
          __result = D.25417 - D.25419;
          {
            D.25420 = __s2_len != 0;
            D.25421 = __result == 0;
            D.25422 = D.25420 & D.25421;
            if (D.25422 != 0) goto <D.25423>; else goto <D.25424>;
            <D.25423>:
            D.25425 = &MEM[(void *)"--break" + 1B];
            D.25426 = *D.25425;
            D.25427 = (int) D.25426;
            D.25428 = __s2 + 1;
            D.25429 = *D.25428;
            D.25430 = (int) D.25429;
            __result = D.25427 - D.25430;
            D.25431 = __s2_len > 1;
            D.25421 = __result == 0;
            D.25432 = D.25431 & D.25421;
            if (D.25432 != 0) goto <D.25433>; else goto <D.25434>;
            <D.25433>:
            D.25435 = &MEM[(void *)"--break" + 2B];
            D.25436 = *D.25435;
            D.25437 = (int) D.25436;
            D.25438 = __s2 + 2;
            D.25439 = *D.25438;
            D.25440 = (int) D.25439;
            __result = D.25437 - D.25440;
            D.25441 = __s2_len > 2;
            D.25421 = __result == 0;
            D.25442 = D.25441 & D.25421;
            if (D.25442 != 0) goto <D.25443>; else goto <D.25444>;
            <D.25443>:
            D.25445 = &MEM[(void *)"--break" + 3B];
            D.25446 = *D.25445;
            D.25447 = (int) D.25446;
            D.25448 = __s2 + 3;
            D.25449 = *D.25448;
            D.25450 = (int) D.25449;
            __result = D.25447 - D.25450;
            <D.25444>:
            <D.25434>:
            <D.25424>:
          }
          D.23762 = __result;
        }
        iftmp.41 = -D.23762;
        goto <D.25451>;
        <D.25414>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.41 = __builtin_strcmp (D.24647, "--break");
        <D.25451>:
        D.23763 = iftmp.41;
      }
      if (D.23763 == 0) goto <D.25452>; else goto <D.25453>;
      <D.25452>:
      D.25130 = i + 1;
      if (D.25130 >= argc) goto <D.25454>; else goto <D.25455>;
      <D.25454>:
      stderr.33 = stderr;
      fprintf (stderr.33, "Missing method name in --break command line option\n");
      D.24875 = 1;
      return D.24875;
      <D.25455>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25456 = mono_debugger_insert_breakpoint (D.24647, 0);
      if (D.25456 == 0) goto <D.25457>; else goto <D.25458>;
      <D.25457>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      stderr.33 = stderr;
      fprintf (stderr.33, "Error: invalid method name \'%s\'\n", D.24647);
      <D.25458>:
      goto <D.25459>;
      <D.25453>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 13;
        if (__s2_len <= 3) goto <D.25461>; else goto <D.25462>;
        <D.25461>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25463 = "--break-at-bb";
          D.25464 = MEM[(const unsigned char *)D.25463];
          D.25465 = (int) D.25464;
          D.25466 = *__s2;
          D.25467 = (int) D.25466;
          __result = D.25465 - D.25467;
          {
            D.25468 = __s2_len != 0;
            D.25469 = __result == 0;
            D.25470 = D.25468 & D.25469;
            if (D.25470 != 0) goto <D.25471>; else goto <D.25472>;
            <D.25471>:
            D.25473 = &MEM[(void *)"--break-at-bb" + 1B];
            D.25474 = *D.25473;
            D.25475 = (int) D.25474;
            D.25476 = __s2 + 1;
            D.25477 = *D.25476;
            D.25478 = (int) D.25477;
            __result = D.25475 - D.25478;
            D.25479 = __s2_len > 1;
            D.25469 = __result == 0;
            D.25480 = D.25479 & D.25469;
            if (D.25480 != 0) goto <D.25481>; else goto <D.25482>;
            <D.25481>:
            D.25483 = &MEM[(void *)"--break-at-bb" + 2B];
            D.25484 = *D.25483;
            D.25485 = (int) D.25484;
            D.25486 = __s2 + 2;
            D.25487 = *D.25486;
            D.25488 = (int) D.25487;
            __result = D.25485 - D.25488;
            D.25489 = __s2_len > 2;
            D.25469 = __result == 0;
            D.25490 = D.25489 & D.25469;
            if (D.25490 != 0) goto <D.25491>; else goto <D.25492>;
            <D.25491>:
            D.25493 = &MEM[(void *)"--break-at-bb" + 3B];
            D.25494 = *D.25493;
            D.25495 = (int) D.25494;
            D.25496 = __s2 + 3;
            D.25497 = *D.25496;
            D.25498 = (int) D.25497;
            __result = D.25495 - D.25498;
            <D.25492>:
            <D.25482>:
            <D.25472>:
          }
          D.23771 = __result;
        }
        iftmp.42 = -D.23771;
        goto <D.25499>;
        <D.25462>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.42 = __builtin_strcmp (D.24647, "--break-at-bb");
        <D.25499>:
        D.23772 = iftmp.42;
      }
      if (D.23772 == 0) goto <D.25500>; else goto <D.25501>;
      <D.25500>:
      D.25502 = i + 2;
      if (D.25502 >= argc) goto <D.25503>; else goto <D.25504>;
      <D.25503>:
      stderr.33 = stderr;
      fprintf (stderr.33, "Missing method name or bb num in --break-at-bb command line option.");
      D.24875 = 1;
      return D.24875;
      <D.25504>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      mono_break_at_bb_method.43 = mono_method_desc_new (D.24647, 1);
      mono_break_at_bb_method = mono_break_at_bb_method.43;
      mono_break_at_bb_method.44 = mono_break_at_bb_method;
      if (mono_break_at_bb_method.44 == 0B) goto <D.25507>; else goto <D.25508>;
      <D.25507>:
      stderr.33 = stderr;
      fprintf (stderr.33, "Method name is in a bad format in --break-at-bb command line option.");
      D.24875 = 1;
      return D.24875;
      <D.25508>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      mono_break_at_bb_bb_num.45 = atoi (D.24647);
      mono_break_at_bb_bb_num = mono_break_at_bb_bb_num.45;
      goto <D.25510>;
      <D.25501>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 18;
        if (__s2_len <= 3) goto <D.25512>; else goto <D.25513>;
        <D.25512>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25514 = "--inject-async-exc";
          D.25515 = MEM[(const unsigned char *)D.25514];
          D.25516 = (int) D.25515;
          D.25517 = *__s2;
          D.25518 = (int) D.25517;
          __result = D.25516 - D.25518;
          {
            D.25519 = __s2_len != 0;
            D.25520 = __result == 0;
            D.25521 = D.25519 & D.25520;
            if (D.25521 != 0) goto <D.25522>; else goto <D.25523>;
            <D.25522>:
            D.25524 = &MEM[(void *)"--inject-async-exc" + 1B];
            D.25525 = *D.25524;
            D.25526 = (int) D.25525;
            D.25527 = __s2 + 1;
            D.25528 = *D.25527;
            D.25529 = (int) D.25528;
            __result = D.25526 - D.25529;
            D.25530 = __s2_len > 1;
            D.25520 = __result == 0;
            D.25531 = D.25530 & D.25520;
            if (D.25531 != 0) goto <D.25532>; else goto <D.25533>;
            <D.25532>:
            D.25534 = &MEM[(void *)"--inject-async-exc" + 2B];
            D.25535 = *D.25534;
            D.25536 = (int) D.25535;
            D.25537 = __s2 + 2;
            D.25538 = *D.25537;
            D.25539 = (int) D.25538;
            __result = D.25536 - D.25539;
            D.25540 = __s2_len > 2;
            D.25520 = __result == 0;
            D.25541 = D.25540 & D.25520;
            if (D.25541 != 0) goto <D.25542>; else goto <D.25543>;
            <D.25542>:
            D.25544 = &MEM[(void *)"--inject-async-exc" + 3B];
            D.25545 = *D.25544;
            D.25546 = (int) D.25545;
            D.25547 = __s2 + 3;
            D.25548 = *D.25547;
            D.25549 = (int) D.25548;
            __result = D.25546 - D.25549;
            <D.25543>:
            <D.25533>:
            <D.25523>:
          }
          D.23780 = __result;
        }
        iftmp.46 = -D.23780;
        goto <D.25550>;
        <D.25513>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.46 = __builtin_strcmp (D.24647, "--inject-async-exc");
        <D.25550>:
        D.23781 = iftmp.46;
      }
      if (D.23781 == 0) goto <D.25551>; else goto <D.25552>;
      <D.25551>:
      D.25502 = i + 2;
      if (D.25502 >= argc) goto <D.25553>; else goto <D.25554>;
      <D.25553>:
      stderr.33 = stderr;
      fprintf (stderr.33, "Missing method name or position in --inject-async-exc command line option\n");
      D.24875 = 1;
      return D.24875;
      <D.25554>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      mono_inject_async_exc_method.47 = mono_method_desc_new (D.24647, 1);
      mono_inject_async_exc_method = mono_inject_async_exc_method.47;
      mono_inject_async_exc_method.48 = mono_inject_async_exc_method;
      if (mono_inject_async_exc_method.48 == 0B) goto <D.25557>; else goto <D.25558>;
      <D.25557>:
      stderr.33 = stderr;
      fprintf (stderr.33, "Method name is in a bad format in --inject-async-exc command line option\n");
      D.24875 = 1;
      return D.24875;
      <D.25558>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      mono_inject_async_exc_pos.49 = atoi (D.24647);
      mono_inject_async_exc_pos = mono_inject_async_exc_pos.49;
      goto <D.25560>;
      <D.25552>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.25562>; else goto <D.25563>;
        <D.25562>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25564 = "--verify-all";
          D.25565 = MEM[(const unsigned char *)D.25564];
          D.25566 = (int) D.25565;
          D.25567 = *__s2;
          D.25568 = (int) D.25567;
          __result = D.25566 - D.25568;
          {
            D.25569 = __s2_len != 0;
            D.25570 = __result == 0;
            D.25571 = D.25569 & D.25570;
            if (D.25571 != 0) goto <D.25572>; else goto <D.25573>;
            <D.25572>:
            D.25574 = &MEM[(void *)"--verify-all" + 1B];
            D.25575 = *D.25574;
            D.25576 = (int) D.25575;
            D.25577 = __s2 + 1;
            D.25578 = *D.25577;
            D.25579 = (int) D.25578;
            __result = D.25576 - D.25579;
            D.25580 = __s2_len > 1;
            D.25570 = __result == 0;
            D.25581 = D.25580 & D.25570;
            if (D.25581 != 0) goto <D.25582>; else goto <D.25583>;
            <D.25582>:
            D.25584 = &MEM[(void *)"--verify-all" + 2B];
            D.25585 = *D.25584;
            D.25586 = (int) D.25585;
            D.25587 = __s2 + 2;
            D.25588 = *D.25587;
            D.25589 = (int) D.25588;
            __result = D.25586 - D.25589;
            D.25590 = __s2_len > 2;
            D.25570 = __result == 0;
            D.25591 = D.25590 & D.25570;
            if (D.25591 != 0) goto <D.25592>; else goto <D.25593>;
            <D.25592>:
            D.25594 = &MEM[(void *)"--verify-all" + 3B];
            D.25595 = *D.25594;
            D.25596 = (int) D.25595;
            D.25597 = __s2 + 3;
            D.25598 = *D.25597;
            D.25599 = (int) D.25598;
            __result = D.25596 - D.25599;
            <D.25593>:
            <D.25583>:
            <D.25573>:
          }
          D.23789 = __result;
        }
        iftmp.50 = -D.23789;
        goto <D.25600>;
        <D.25563>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.50 = __builtin_strcmp (D.24647, "--verify-all");
        <D.25600>:
        D.23790 = iftmp.50;
      }
      if (D.23790 == 0) goto <D.25601>; else goto <D.25602>;
      <D.25601>:
      mono_verifier_enable_verify_all ();
      goto <D.25603>;
      <D.25602>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 10;
        if (__s2_len <= 3) goto <D.25605>; else goto <D.25606>;
        <D.25605>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25607 = "--full-aot";
          D.25608 = MEM[(const unsigned char *)D.25607];
          D.25609 = (int) D.25608;
          D.25610 = *__s2;
          D.25611 = (int) D.25610;
          __result = D.25609 - D.25611;
          {
            D.25612 = __s2_len != 0;
            D.25613 = __result == 0;
            D.25614 = D.25612 & D.25613;
            if (D.25614 != 0) goto <D.25615>; else goto <D.25616>;
            <D.25615>:
            D.25617 = &MEM[(void *)"--full-aot" + 1B];
            D.25618 = *D.25617;
            D.25619 = (int) D.25618;
            D.25620 = __s2 + 1;
            D.25621 = *D.25620;
            D.25622 = (int) D.25621;
            __result = D.25619 - D.25622;
            D.25623 = __s2_len > 1;
            D.25613 = __result == 0;
            D.25624 = D.25623 & D.25613;
            if (D.25624 != 0) goto <D.25625>; else goto <D.25626>;
            <D.25625>:
            D.25627 = &MEM[(void *)"--full-aot" + 2B];
            D.25628 = *D.25627;
            D.25629 = (int) D.25628;
            D.25630 = __s2 + 2;
            D.25631 = *D.25630;
            D.25632 = (int) D.25631;
            __result = D.25629 - D.25632;
            D.25633 = __s2_len > 2;
            D.25613 = __result == 0;
            D.25634 = D.25633 & D.25613;
            if (D.25634 != 0) goto <D.25635>; else goto <D.25636>;
            <D.25635>:
            D.25637 = &MEM[(void *)"--full-aot" + 3B];
            D.25638 = *D.25637;
            D.25639 = (int) D.25638;
            D.25640 = __s2 + 3;
            D.25641 = *D.25640;
            D.25642 = (int) D.25641;
            __result = D.25639 - D.25642;
            <D.25636>:
            <D.25626>:
            <D.25616>:
          }
          D.23798 = __result;
        }
        iftmp.51 = -D.23798;
        goto <D.25643>;
        <D.25606>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.51 = __builtin_strcmp (D.24647, "--full-aot");
        <D.25643>:
        D.23799 = iftmp.51;
      }
      if (D.23799 == 0) goto <D.25644>; else goto <D.25645>;
      <D.25644>:
      mono_aot_only = 1;
      goto <D.25646>;
      <D.25645>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 14;
        if (__s2_len <= 3) goto <D.25648>; else goto <D.25649>;
        <D.25648>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25650 = "--print-vtable";
          D.25651 = MEM[(const unsigned char *)D.25650];
          D.25652 = (int) D.25651;
          D.25653 = *__s2;
          D.25654 = (int) D.25653;
          __result = D.25652 - D.25654;
          {
            D.25655 = __s2_len != 0;
            D.25656 = __result == 0;
            D.25657 = D.25655 & D.25656;
            if (D.25657 != 0) goto <D.25658>; else goto <D.25659>;
            <D.25658>:
            D.25660 = &MEM[(void *)"--print-vtable" + 1B];
            D.25661 = *D.25660;
            D.25662 = (int) D.25661;
            D.25663 = __s2 + 1;
            D.25664 = *D.25663;
            D.25665 = (int) D.25664;
            __result = D.25662 - D.25665;
            D.25666 = __s2_len > 1;
            D.25656 = __result == 0;
            D.25667 = D.25666 & D.25656;
            if (D.25667 != 0) goto <D.25668>; else goto <D.25669>;
            <D.25668>:
            D.25670 = &MEM[(void *)"--print-vtable" + 2B];
            D.25671 = *D.25670;
            D.25672 = (int) D.25671;
            D.25673 = __s2 + 2;
            D.25674 = *D.25673;
            D.25675 = (int) D.25674;
            __result = D.25672 - D.25675;
            D.25676 = __s2_len > 2;
            D.25656 = __result == 0;
            D.25677 = D.25676 & D.25656;
            if (D.25677 != 0) goto <D.25678>; else goto <D.25679>;
            <D.25678>:
            D.25680 = &MEM[(void *)"--print-vtable" + 3B];
            D.25681 = *D.25680;
            D.25682 = (int) D.25681;
            D.25683 = __s2 + 3;
            D.25684 = *D.25683;
            D.25685 = (int) D.25684;
            __result = D.25682 - D.25685;
            <D.25679>:
            <D.25669>:
            <D.25659>:
          }
          D.23807 = __result;
        }
        iftmp.52 = -D.23807;
        goto <D.25686>;
        <D.25649>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.52 = __builtin_strcmp (D.24647, "--print-vtable");
        <D.25686>:
        D.23808 = iftmp.52;
      }
      if (D.23808 == 0) goto <D.25687>; else goto <D.25688>;
      <D.25687>:
      mono_print_vtable = 1;
      goto <D.25689>;
      <D.25688>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.25691>; else goto <D.25692>;
        <D.25691>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25693 = "--stats";
          D.25694 = MEM[(const unsigned char *)D.25693];
          D.25695 = (int) D.25694;
          D.25696 = *__s2;
          D.25697 = (int) D.25696;
          __result = D.25695 - D.25697;
          {
            D.25698 = __s2_len != 0;
            D.25699 = __result == 0;
            D.25700 = D.25698 & D.25699;
            if (D.25700 != 0) goto <D.25701>; else goto <D.25702>;
            <D.25701>:
            D.25703 = &MEM[(void *)"--stats" + 1B];
            D.25704 = *D.25703;
            D.25705 = (int) D.25704;
            D.25706 = __s2 + 1;
            D.25707 = *D.25706;
            D.25708 = (int) D.25707;
            __result = D.25705 - D.25708;
            D.25709 = __s2_len > 1;
            D.25699 = __result == 0;
            D.25710 = D.25709 & D.25699;
            if (D.25710 != 0) goto <D.25711>; else goto <D.25712>;
            <D.25711>:
            D.25713 = &MEM[(void *)"--stats" + 2B];
            D.25714 = *D.25713;
            D.25715 = (int) D.25714;
            D.25716 = __s2 + 2;
            D.25717 = *D.25716;
            D.25718 = (int) D.25717;
            __result = D.25715 - D.25718;
            D.25719 = __s2_len > 2;
            D.25699 = __result == 0;
            D.25720 = D.25719 & D.25699;
            if (D.25720 != 0) goto <D.25721>; else goto <D.25722>;
            <D.25721>:
            D.25723 = &MEM[(void *)"--stats" + 3B];
            D.25724 = *D.25723;
            D.25725 = (int) D.25724;
            D.25726 = __s2 + 3;
            D.25727 = *D.25726;
            D.25728 = (int) D.25727;
            __result = D.25725 - D.25728;
            <D.25722>:
            <D.25712>:
            <D.25702>:
          }
          D.23816 = __result;
        }
        iftmp.53 = -D.23816;
        goto <D.25729>;
        <D.25692>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.53 = __builtin_strcmp (D.24647, "--stats");
        <D.25729>:
        D.23817 = iftmp.53;
      }
      if (D.23817 == 0) goto <D.25730>; else goto <D.25731>;
      <D.25730>:
      mono_counters_enable (-1);
      mono_stats.enabled = 1;
      mono_jit_stats.enabled = 1;
      goto <D.25732>;
      <D.25731>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.25734>; else goto <D.25735>;
        <D.25734>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25736 = "--aot";
          D.25737 = MEM[(const unsigned char *)D.25736];
          D.25738 = (int) D.25737;
          D.25739 = *__s2;
          D.25740 = (int) D.25739;
          __result = D.25738 - D.25740;
          {
            D.25741 = __s2_len != 0;
            D.25742 = __result == 0;
            D.25743 = D.25741 & D.25742;
            if (D.25743 != 0) goto <D.25744>; else goto <D.25745>;
            <D.25744>:
            D.25746 = &MEM[(void *)"--aot" + 1B];
            D.25747 = *D.25746;
            D.25748 = (int) D.25747;
            D.25749 = __s2 + 1;
            D.25750 = *D.25749;
            D.25751 = (int) D.25750;
            __result = D.25748 - D.25751;
            D.25752 = __s2_len > 1;
            D.25742 = __result == 0;
            D.25753 = D.25752 & D.25742;
            if (D.25753 != 0) goto <D.25754>; else goto <D.25755>;
            <D.25754>:
            D.25756 = &MEM[(void *)"--aot" + 2B];
            D.25757 = *D.25756;
            D.25758 = (int) D.25757;
            D.25759 = __s2 + 2;
            D.25760 = *D.25759;
            D.25761 = (int) D.25760;
            __result = D.25758 - D.25761;
            D.25762 = __s2_len > 2;
            D.25742 = __result == 0;
            D.25763 = D.25762 & D.25742;
            if (D.25763 != 0) goto <D.25764>; else goto <D.25765>;
            <D.25764>:
            D.25766 = &MEM[(void *)"--aot" + 3B];
            D.25767 = *D.25766;
            D.25768 = (int) D.25767;
            D.25769 = __s2 + 3;
            D.25770 = *D.25769;
            D.25771 = (int) D.25770;
            __result = D.25768 - D.25771;
            <D.25765>:
            <D.25755>:
            <D.25745>:
          }
          D.23825 = __result;
        }
        iftmp.54 = -D.23825;
        goto <D.25772>;
        <D.25735>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.54 = __builtin_strcmp (D.24647, "--aot");
        <D.25772>:
        D.23826 = iftmp.54;
      }
      if (D.23826 == 0) goto <D.25773>; else goto <D.25774>;
      <D.25773>:
      mono_compile_aot = 1;
      goto <D.25775>;
      <D.25774>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25776 = strncmp (D.24647, "--aot=", 6);
      if (D.25776 == 0) goto <D.25777>; else goto <D.25778>;
      <D.25777>:
      mono_compile_aot = 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      aot_options = D.24647 + 6;
      goto <D.25779>;
      <D.25778>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25780 = strncmp (D.24647, "--compile-all=", 14);
      if (D.25780 == 0) goto <D.25781>; else goto <D.25782>;
      <D.25781>:
      action = 3;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25783 = D.24647 + 14;
      D.25784 = atoi (D.25783);
      recompilation_times = (guint32) D.25784;
      goto <D.25785>;
      <D.25782>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 13;
        if (__s2_len <= 3) goto <D.25787>; else goto <D.25788>;
        <D.25787>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25789 = "--compile-all";
          D.25790 = MEM[(const unsigned char *)D.25789];
          D.25791 = (int) D.25790;
          D.25792 = *__s2;
          D.25793 = (int) D.25792;
          __result = D.25791 - D.25793;
          {
            D.25794 = __s2_len != 0;
            D.25795 = __result == 0;
            D.25796 = D.25794 & D.25795;
            if (D.25796 != 0) goto <D.25797>; else goto <D.25798>;
            <D.25797>:
            D.25799 = &MEM[(void *)"--compile-all" + 1B];
            D.25800 = *D.25799;
            D.25801 = (int) D.25800;
            D.25802 = __s2 + 1;
            D.25803 = *D.25802;
            D.25804 = (int) D.25803;
            __result = D.25801 - D.25804;
            D.25805 = __s2_len > 1;
            D.25795 = __result == 0;
            D.25806 = D.25805 & D.25795;
            if (D.25806 != 0) goto <D.25807>; else goto <D.25808>;
            <D.25807>:
            D.25809 = &MEM[(void *)"--compile-all" + 2B];
            D.25810 = *D.25809;
            D.25811 = (int) D.25810;
            D.25812 = __s2 + 2;
            D.25813 = *D.25812;
            D.25814 = (int) D.25813;
            __result = D.25811 - D.25814;
            D.25815 = __s2_len > 2;
            D.25795 = __result == 0;
            D.25816 = D.25815 & D.25795;
            if (D.25816 != 0) goto <D.25817>; else goto <D.25818>;
            <D.25817>:
            D.25819 = &MEM[(void *)"--compile-all" + 3B];
            D.25820 = *D.25819;
            D.25821 = (int) D.25820;
            D.25822 = __s2 + 3;
            D.25823 = *D.25822;
            D.25824 = (int) D.25823;
            __result = D.25821 - D.25824;
            <D.25818>:
            <D.25808>:
            <D.25798>:
          }
          D.23852 = __result;
        }
        iftmp.55 = -D.23852;
        goto <D.25825>;
        <D.25788>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.55 = __builtin_strcmp (D.24647, "--compile-all");
        <D.25825>:
        D.23853 = iftmp.55;
      }
      if (D.23853 == 0) goto <D.25826>; else goto <D.25827>;
      <D.25826>:
      action = 3;
      goto <D.25828>;
      <D.25827>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25829 = strncmp (D.24647, "--runtime=", 10);
      if (D.25829 == 0) goto <D.25830>; else goto <D.25831>;
      <D.25830>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      forced_version = D.24647 + 10;
      goto <D.25832>;
      <D.25831>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.25834>; else goto <D.25835>;
        <D.25834>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25836 = "--jitmap";
          D.25837 = MEM[(const unsigned char *)D.25836];
          D.25838 = (int) D.25837;
          D.25839 = *__s2;
          D.25840 = (int) D.25839;
          __result = D.25838 - D.25840;
          {
            D.25841 = __s2_len != 0;
            D.25842 = __result == 0;
            D.25843 = D.25841 & D.25842;
            if (D.25843 != 0) goto <D.25844>; else goto <D.25845>;
            <D.25844>:
            D.25846 = &MEM[(void *)"--jitmap" + 1B];
            D.25847 = *D.25846;
            D.25848 = (int) D.25847;
            D.25849 = __s2 + 1;
            D.25850 = *D.25849;
            D.25851 = (int) D.25850;
            __result = D.25848 - D.25851;
            D.25852 = __s2_len > 1;
            D.25842 = __result == 0;
            D.25853 = D.25852 & D.25842;
            if (D.25853 != 0) goto <D.25854>; else goto <D.25855>;
            <D.25854>:
            D.25856 = &MEM[(void *)"--jitmap" + 2B];
            D.25857 = *D.25856;
            D.25858 = (int) D.25857;
            D.25859 = __s2 + 2;
            D.25860 = *D.25859;
            D.25861 = (int) D.25860;
            __result = D.25858 - D.25861;
            D.25862 = __s2_len > 2;
            D.25842 = __result == 0;
            D.25863 = D.25862 & D.25842;
            if (D.25863 != 0) goto <D.25864>; else goto <D.25865>;
            <D.25864>:
            D.25866 = &MEM[(void *)"--jitmap" + 3B];
            D.25867 = *D.25866;
            D.25868 = (int) D.25867;
            D.25869 = __s2 + 3;
            D.25870 = *D.25869;
            D.25871 = (int) D.25870;
            __result = D.25868 - D.25871;
            <D.25865>:
            <D.25855>:
            <D.25845>:
          }
          D.23870 = __result;
        }
        iftmp.56 = -D.23870;
        goto <D.25872>;
        <D.25835>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.56 = __builtin_strcmp (D.24647, "--jitmap");
        <D.25872>:
        D.23871 = iftmp.56;
      }
      if (D.23871 == 0) goto <D.25873>; else goto <D.25874>;
      <D.25873>:
      mono_enable_jit_map ();
      goto <D.25875>;
      <D.25874>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 9;
        if (__s2_len <= 3) goto <D.25877>; else goto <D.25878>;
        <D.25877>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25879 = "--profile";
          D.25880 = MEM[(const unsigned char *)D.25879];
          D.25881 = (int) D.25880;
          D.25882 = *__s2;
          D.25883 = (int) D.25882;
          __result = D.25881 - D.25883;
          {
            D.25884 = __s2_len != 0;
            D.25885 = __result == 0;
            D.25886 = D.25884 & D.25885;
            if (D.25886 != 0) goto <D.25887>; else goto <D.25888>;
            <D.25887>:
            D.25889 = &MEM[(void *)"--profile" + 1B];
            D.25890 = *D.25889;
            D.25891 = (int) D.25890;
            D.25892 = __s2 + 1;
            D.25893 = *D.25892;
            D.25894 = (int) D.25893;
            __result = D.25891 - D.25894;
            D.25895 = __s2_len > 1;
            D.25885 = __result == 0;
            D.25896 = D.25895 & D.25885;
            if (D.25896 != 0) goto <D.25897>; else goto <D.25898>;
            <D.25897>:
            D.25899 = &MEM[(void *)"--profile" + 2B];
            D.25900 = *D.25899;
            D.25901 = (int) D.25900;
            D.25902 = __s2 + 2;
            D.25903 = *D.25902;
            D.25904 = (int) D.25903;
            __result = D.25901 - D.25904;
            D.25905 = __s2_len > 2;
            D.25885 = __result == 0;
            D.25906 = D.25905 & D.25885;
            if (D.25906 != 0) goto <D.25907>; else goto <D.25908>;
            <D.25907>:
            D.25909 = &MEM[(void *)"--profile" + 3B];
            D.25910 = *D.25909;
            D.25911 = (int) D.25910;
            D.25912 = __s2 + 3;
            D.25913 = *D.25912;
            D.25914 = (int) D.25913;
            __result = D.25911 - D.25914;
            <D.25908>:
            <D.25898>:
            <D.25888>:
          }
          D.23879 = __result;
        }
        iftmp.57 = -D.23879;
        goto <D.25915>;
        <D.25878>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.57 = __builtin_strcmp (D.24647, "--profile");
        <D.25915>:
        D.23880 = iftmp.57;
      }
      if (D.23880 == 0) goto <D.25916>; else goto <D.25917>;
      <D.25916>:
      enable_profile = 1;
      profile_options = 0B;
      goto <D.25918>;
      <D.25917>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25919 = strncmp (D.24647, "--profile=", 10);
      if (D.25919 == 0) goto <D.25920>; else goto <D.25921>;
      <D.25920>:
      enable_profile = 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      profile_options = D.24647 + 10;
      goto <D.25922>;
      <D.25921>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25923 = strncmp (D.24647, "--agent=", 8);
      if (D.25923 == 0) goto <D.25924>; else goto <D.25925>;
      <D.25924>:
      if (agents == 0B) goto <D.25926>; else goto <D.25927>;
      <D.25926>:
      agents = monoeg_g_ptr_array_new ();
      <D.25927>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25928 = D.24647 + 8;
      monoeg_g_ptr_array_add (agents, D.25928);
      goto <D.25929>;
      <D.25925>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25930 = strncmp (D.24647, "--attach=", 9);
      if (D.25930 == 0) goto <D.25931>; else goto <D.25932>;
      <D.25931>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      attach_options = D.24647 + 9;
      goto <D.25933>;
      <D.25932>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 9;
        if (__s2_len <= 3) goto <D.25935>; else goto <D.25936>;
        <D.25935>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25937 = "--compile";
          D.25938 = MEM[(const unsigned char *)D.25937];
          D.25939 = (int) D.25938;
          D.25940 = *__s2;
          D.25941 = (int) D.25940;
          __result = D.25939 - D.25941;
          {
            D.25942 = __s2_len != 0;
            D.25943 = __result == 0;
            D.25944 = D.25942 & D.25943;
            if (D.25944 != 0) goto <D.25945>; else goto <D.25946>;
            <D.25945>:
            D.25947 = &MEM[(void *)"--compile" + 1B];
            D.25948 = *D.25947;
            D.25949 = (int) D.25948;
            D.25950 = __s2 + 1;
            D.25951 = *D.25950;
            D.25952 = (int) D.25951;
            __result = D.25949 - D.25952;
            D.25953 = __s2_len > 1;
            D.25943 = __result == 0;
            D.25954 = D.25953 & D.25943;
            if (D.25954 != 0) goto <D.25955>; else goto <D.25956>;
            <D.25955>:
            D.25957 = &MEM[(void *)"--compile" + 2B];
            D.25958 = *D.25957;
            D.25959 = (int) D.25958;
            D.25960 = __s2 + 2;
            D.25961 = *D.25960;
            D.25962 = (int) D.25961;
            __result = D.25959 - D.25962;
            D.25963 = __s2_len > 2;
            D.25943 = __result == 0;
            D.25964 = D.25963 & D.25943;
            if (D.25964 != 0) goto <D.25965>; else goto <D.25966>;
            <D.25965>:
            D.25967 = &MEM[(void *)"--compile" + 3B];
            D.25968 = *D.25967;
            D.25969 = (int) D.25968;
            D.25970 = __s2 + 3;
            D.25971 = *D.25970;
            D.25972 = (int) D.25971;
            __result = D.25969 - D.25972;
            <D.25966>:
            <D.25956>:
            <D.25946>:
          }
          D.23915 = __result;
        }
        iftmp.58 = -D.23915;
        goto <D.25973>;
        <D.25936>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.58 = __builtin_strcmp (D.24647, "--compile");
        <D.25973>:
        D.23916 = iftmp.58;
      }
      if (D.23916 == 0) goto <D.25974>; else goto <D.25975>;
      <D.25974>:
      D.25130 = i + 1;
      if (D.25130 >= argc) goto <D.25976>; else goto <D.25977>;
      <D.25976>:
      stderr.33 = stderr;
      fprintf (stderr.33, "error: --compile option requires a method name argument\n");
      D.24875 = 1;
      return D.24875;
      <D.25977>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      mname = *D.24646;
      action = 0;
      goto <D.25978>;
      <D.25975>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25979 = strncmp (D.24647, "--graph=", 8);
      if (D.25979 == 0) goto <D.25980>; else goto <D.25981>;
      <D.25980>:
      D.25130 = i + 1;
      if (D.25130 >= argc) goto <D.25982>; else goto <D.25983>;
      <D.25982>:
      stderr.33 = stderr;
      fprintf (stderr.33, "error: --graph option requires a method name argument\n");
      D.24875 = 1;
      return D.24875;
      <D.25983>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25984 = D.24647 + 8;
      mono_graph_options = mono_parse_graph_options (D.25984);
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      mname = *D.24646;
      action = 5;
      goto <D.25985>;
      <D.25981>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.25987>; else goto <D.25988>;
        <D.25987>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.25989 = "--graph";
          D.25990 = MEM[(const unsigned char *)D.25989];
          D.25991 = (int) D.25990;
          D.25992 = *__s2;
          D.25993 = (int) D.25992;
          __result = D.25991 - D.25993;
          {
            D.25994 = __s2_len != 0;
            D.25995 = __result == 0;
            D.25996 = D.25994 & D.25995;
            if (D.25996 != 0) goto <D.25997>; else goto <D.25998>;
            <D.25997>:
            D.25999 = &MEM[(void *)"--graph" + 1B];
            D.26000 = *D.25999;
            D.26001 = (int) D.26000;
            D.26002 = __s2 + 1;
            D.26003 = *D.26002;
            D.26004 = (int) D.26003;
            __result = D.26001 - D.26004;
            D.26005 = __s2_len > 1;
            D.25995 = __result == 0;
            D.26006 = D.26005 & D.25995;
            if (D.26006 != 0) goto <D.26007>; else goto <D.26008>;
            <D.26007>:
            D.26009 = &MEM[(void *)"--graph" + 2B];
            D.26010 = *D.26009;
            D.26011 = (int) D.26010;
            D.26012 = __s2 + 2;
            D.26013 = *D.26012;
            D.26014 = (int) D.26013;
            __result = D.26011 - D.26014;
            D.26015 = __s2_len > 2;
            D.25995 = __result == 0;
            D.26016 = D.26015 & D.25995;
            if (D.26016 != 0) goto <D.26017>; else goto <D.26018>;
            <D.26017>:
            D.26019 = &MEM[(void *)"--graph" + 3B];
            D.26020 = *D.26019;
            D.26021 = (int) D.26020;
            D.26022 = __s2 + 3;
            D.26023 = *D.26022;
            D.26024 = (int) D.26023;
            __result = D.26021 - D.26024;
            <D.26018>:
            <D.26008>:
            <D.25998>:
          }
          D.23933 = __result;
        }
        iftmp.59 = -D.23933;
        goto <D.26025>;
        <D.25988>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.59 = __builtin_strcmp (D.24647, "--graph");
        <D.26025>:
        D.23934 = iftmp.59;
      }
      if (D.23934 == 0) goto <D.26026>; else goto <D.26027>;
      <D.26026>:
      D.25130 = i + 1;
      if (D.25130 >= argc) goto <D.26028>; else goto <D.26029>;
      <D.26028>:
      stderr.33 = stderr;
      fprintf (stderr.33, "error: --graph option requires a method name argument\n");
      D.24875 = 1;
      return D.24875;
      <D.26029>:
      i = i + 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      mname = *D.24646;
      mono_graph_options = 1;
      action = 5;
      goto <D.26030>;
      <D.26027>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.26032>; else goto <D.26033>;
        <D.26032>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26034 = "--debug";
          D.26035 = MEM[(const unsigned char *)D.26034];
          D.26036 = (int) D.26035;
          D.26037 = *__s2;
          D.26038 = (int) D.26037;
          __result = D.26036 - D.26038;
          {
            D.26039 = __s2_len != 0;
            D.26040 = __result == 0;
            D.26041 = D.26039 & D.26040;
            if (D.26041 != 0) goto <D.26042>; else goto <D.26043>;
            <D.26042>:
            D.26044 = &MEM[(void *)"--debug" + 1B];
            D.26045 = *D.26044;
            D.26046 = (int) D.26045;
            D.26047 = __s2 + 1;
            D.26048 = *D.26047;
            D.26049 = (int) D.26048;
            __result = D.26046 - D.26049;
            D.26050 = __s2_len > 1;
            D.26040 = __result == 0;
            D.26051 = D.26050 & D.26040;
            if (D.26051 != 0) goto <D.26052>; else goto <D.26053>;
            <D.26052>:
            D.26054 = &MEM[(void *)"--debug" + 2B];
            D.26055 = *D.26054;
            D.26056 = (int) D.26055;
            D.26057 = __s2 + 2;
            D.26058 = *D.26057;
            D.26059 = (int) D.26058;
            __result = D.26056 - D.26059;
            D.26060 = __s2_len > 2;
            D.26040 = __result == 0;
            D.26061 = D.26060 & D.26040;
            if (D.26061 != 0) goto <D.26062>; else goto <D.26063>;
            <D.26062>:
            D.26064 = &MEM[(void *)"--debug" + 3B];
            D.26065 = *D.26064;
            D.26066 = (int) D.26065;
            D.26067 = __s2 + 3;
            D.26068 = *D.26067;
            D.26069 = (int) D.26068;
            __result = D.26066 - D.26069;
            <D.26063>:
            <D.26053>:
            <D.26043>:
          }
          D.23942 = __result;
        }
        iftmp.60 = -D.23942;
        goto <D.26070>;
        <D.26033>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.60 = __builtin_strcmp (D.24647, "--debug");
        <D.26070>:
        D.23943 = iftmp.60;
      }
      if (D.23943 == 0) goto <D.26071>; else goto <D.26072>;
      <D.26071>:
      enable_debugging = 1;
      goto <D.26073>;
      <D.26072>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.26074 = strncmp (D.24647, "--debug=", 8);
      if (D.26074 == 0) goto <D.26075>; else goto <D.26076>;
      <D.26075>:
      enable_debugging = 1;
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.25984 = D.24647 + 8;
      D.26077 = parse_debug_options (D.25984);
      if (D.26077 == 0) goto <D.26078>; else goto <D.26079>;
      <D.26078>:
      D.24875 = 1;
      return D.24875;
      <D.26079>:
      goto <D.26080>;
      <D.26076>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.26081 = strncmp (D.24647, "--debugger-agent=", 17);
      if (D.26081 == 0) goto <D.26082>; else goto <D.26083>;
      <D.26082>:
      {
        struct MonoDebugOptions * opt;

        opt = mini_get_debug_options ();
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.26084 = D.24647 + 17;
        mono_debugger_agent_parse_options (D.26084);
        opt->mdb_optimizations = 1;
        enable_debugging = 1;
      }
      goto <D.26085>;
      <D.26083>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 10;
        if (__s2_len <= 3) goto <D.26087>; else goto <D.26088>;
        <D.26087>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26089 = "--security";
          D.26090 = MEM[(const unsigned char *)D.26089];
          D.26091 = (int) D.26090;
          D.26092 = *__s2;
          D.26093 = (int) D.26092;
          __result = D.26091 - D.26093;
          {
            D.26094 = __s2_len != 0;
            D.26095 = __result == 0;
            D.26096 = D.26094 & D.26095;
            if (D.26096 != 0) goto <D.26097>; else goto <D.26098>;
            <D.26097>:
            D.26099 = &MEM[(void *)"--security" + 1B];
            D.26100 = *D.26099;
            D.26101 = (int) D.26100;
            D.26102 = __s2 + 1;
            D.26103 = *D.26102;
            D.26104 = (int) D.26103;
            __result = D.26101 - D.26104;
            D.26105 = __s2_len > 1;
            D.26095 = __result == 0;
            D.26106 = D.26105 & D.26095;
            if (D.26106 != 0) goto <D.26107>; else goto <D.26108>;
            <D.26107>:
            D.26109 = &MEM[(void *)"--security" + 2B];
            D.26110 = *D.26109;
            D.26111 = (int) D.26110;
            D.26112 = __s2 + 2;
            D.26113 = *D.26112;
            D.26114 = (int) D.26113;
            __result = D.26111 - D.26114;
            D.26115 = __s2_len > 2;
            D.26095 = __result == 0;
            D.26116 = D.26115 & D.26095;
            if (D.26116 != 0) goto <D.26117>; else goto <D.26118>;
            <D.26117>:
            D.26119 = &MEM[(void *)"--security" + 3B];
            D.26120 = *D.26119;
            D.26121 = (int) D.26120;
            D.26122 = __s2 + 3;
            D.26123 = *D.26122;
            D.26124 = (int) D.26123;
            __result = D.26121 - D.26124;
            <D.26118>:
            <D.26108>:
            <D.26098>:
          }
          D.23970 = __result;
        }
        iftmp.61 = -D.23970;
        goto <D.26125>;
        <D.26088>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.61 = __builtin_strcmp (D.24647, "--security");
        <D.26125>:
        D.23971 = iftmp.61;
      }
      if (D.23971 == 0) goto <D.26126>; else goto <D.26127>;
      <D.26126>:
      mono_verifier_set_mode (2);
      mono_security_set_mode (2);
      mono_activate_security_manager ();
      goto <D.26128>;
      <D.26127>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.26129 = strncmp (D.24647, "--security=", 11);
      if (D.26129 == 0) goto <D.26130>; else goto <D.26131>;
      <D.26130>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 19;
        if (__s2_len <= 3) goto <D.26133>; else goto <D.26134>;
        <D.26133>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 11;
          D.26135 = "temporary-smcs-hack";
          D.26136 = MEM[(const unsigned char *)D.26135];
          D.26137 = (int) D.26136;
          D.26138 = *__s2;
          D.26139 = (int) D.26138;
          __result = D.26137 - D.26139;
          {
            D.26140 = __s2_len != 0;
            D.26141 = __result == 0;
            D.26142 = D.26140 & D.26141;
            if (D.26142 != 0) goto <D.26143>; else goto <D.26144>;
            <D.26143>:
            D.26145 = &MEM[(void *)"temporary-smcs-hack" + 1B];
            D.26146 = *D.26145;
            D.26147 = (int) D.26146;
            D.26148 = __s2 + 1;
            D.26149 = *D.26148;
            D.26150 = (int) D.26149;
            __result = D.26147 - D.26150;
            D.26151 = __s2_len > 1;
            D.26141 = __result == 0;
            D.26152 = D.26151 & D.26141;
            if (D.26152 != 0) goto <D.26153>; else goto <D.26154>;
            <D.26153>:
            D.26155 = &MEM[(void *)"temporary-smcs-hack" + 2B];
            D.26156 = *D.26155;
            D.26157 = (int) D.26156;
            D.26158 = __s2 + 2;
            D.26159 = *D.26158;
            D.26160 = (int) D.26159;
            __result = D.26157 - D.26160;
            D.26161 = __s2_len > 2;
            D.26141 = __result == 0;
            D.26162 = D.26161 & D.26141;
            if (D.26162 != 0) goto <D.26163>; else goto <D.26164>;
            <D.26163>:
            D.26165 = &MEM[(void *)"temporary-smcs-hack" + 3B];
            D.26166 = *D.26165;
            D.26167 = (int) D.26166;
            D.26168 = __s2 + 3;
            D.26169 = *D.26168;
            D.26170 = (int) D.26169;
            __result = D.26167 - D.26170;
            <D.26164>:
            <D.26154>:
            <D.26144>:
          }
          D.23988 = __result;
        }
        iftmp.62 = -D.23988;
        goto <D.26171>;
        <D.26134>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.25139 = D.24647 + 11;
        iftmp.62 = __builtin_strcmp (D.25139, "temporary-smcs-hack");
        <D.26171>:
        D.23989 = iftmp.62;
      }
      if (D.23989 == 0) goto <D.26172>; else goto <D.26173>;
      <D.26172>:
      mono_security_set_mode (3);
      goto <D.26174>;
      <D.26173>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.26176>; else goto <D.26177>;
        <D.26176>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 11;
          D.26178 = "core-clr";
          D.26179 = MEM[(const unsigned char *)D.26178];
          D.26180 = (int) D.26179;
          D.26181 = *__s2;
          D.26182 = (int) D.26181;
          __result = D.26180 - D.26182;
          {
            D.26183 = __s2_len != 0;
            D.26184 = __result == 0;
            D.26185 = D.26183 & D.26184;
            if (D.26185 != 0) goto <D.26186>; else goto <D.26187>;
            <D.26186>:
            D.26188 = &MEM[(void *)"core-clr" + 1B];
            D.26189 = *D.26188;
            D.26190 = (int) D.26189;
            D.26191 = __s2 + 1;
            D.26192 = *D.26191;
            D.26193 = (int) D.26192;
            __result = D.26190 - D.26193;
            D.26194 = __s2_len > 1;
            D.26184 = __result == 0;
            D.26195 = D.26194 & D.26184;
            if (D.26195 != 0) goto <D.26196>; else goto <D.26197>;
            <D.26196>:
            D.26198 = &MEM[(void *)"core-clr" + 2B];
            D.26199 = *D.26198;
            D.26200 = (int) D.26199;
            D.26201 = __s2 + 2;
            D.26202 = *D.26201;
            D.26203 = (int) D.26202;
            __result = D.26200 - D.26203;
            D.26204 = __s2_len > 2;
            D.26184 = __result == 0;
            D.26205 = D.26204 & D.26184;
            if (D.26205 != 0) goto <D.26206>; else goto <D.26207>;
            <D.26206>:
            D.26208 = &MEM[(void *)"core-clr" + 3B];
            D.26209 = *D.26208;
            D.26210 = (int) D.26209;
            D.26211 = __s2 + 3;
            D.26212 = *D.26211;
            D.26213 = (int) D.26212;
            __result = D.26210 - D.26213;
            <D.26207>:
            <D.26197>:
            <D.26187>:
          }
          D.23997 = __result;
        }
        iftmp.63 = -D.23997;
        goto <D.26214>;
        <D.26177>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.25139 = D.24647 + 11;
        iftmp.63 = __builtin_strcmp (D.25139, "core-clr");
        <D.26214>:
        D.23998 = iftmp.63;
      }
      if (D.23998 == 0) goto <D.26215>; else goto <D.26216>;
      <D.26215>:
      mono_verifier_set_mode (2);
      mono_security_set_mode (1);
      goto <D.26217>;
      <D.26216>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 13;
        if (__s2_len <= 3) goto <D.26219>; else goto <D.26220>;
        <D.26219>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 11;
          D.26221 = "core-clr-test";
          D.26222 = MEM[(const unsigned char *)D.26221];
          D.26223 = (int) D.26222;
          D.26224 = *__s2;
          D.26225 = (int) D.26224;
          __result = D.26223 - D.26225;
          {
            D.26226 = __s2_len != 0;
            D.26227 = __result == 0;
            D.26228 = D.26226 & D.26227;
            if (D.26228 != 0) goto <D.26229>; else goto <D.26230>;
            <D.26229>:
            D.26231 = &MEM[(void *)"core-clr-test" + 1B];
            D.26232 = *D.26231;
            D.26233 = (int) D.26232;
            D.26234 = __s2 + 1;
            D.26235 = *D.26234;
            D.26236 = (int) D.26235;
            __result = D.26233 - D.26236;
            D.26237 = __s2_len > 1;
            D.26227 = __result == 0;
            D.26238 = D.26237 & D.26227;
            if (D.26238 != 0) goto <D.26239>; else goto <D.26240>;
            <D.26239>:
            D.26241 = &MEM[(void *)"core-clr-test" + 2B];
            D.26242 = *D.26241;
            D.26243 = (int) D.26242;
            D.26244 = __s2 + 2;
            D.26245 = *D.26244;
            D.26246 = (int) D.26245;
            __result = D.26243 - D.26246;
            D.26247 = __s2_len > 2;
            D.26227 = __result == 0;
            D.26248 = D.26247 & D.26227;
            if (D.26248 != 0) goto <D.26249>; else goto <D.26250>;
            <D.26249>:
            D.26251 = &MEM[(void *)"core-clr-test" + 3B];
            D.26252 = *D.26251;
            D.26253 = (int) D.26252;
            D.26254 = __s2 + 3;
            D.26255 = *D.26254;
            D.26256 = (int) D.26255;
            __result = D.26253 - D.26256;
            <D.26250>:
            <D.26240>:
            <D.26230>:
          }
          D.24006 = __result;
        }
        iftmp.64 = -D.24006;
        goto <D.26257>;
        <D.26220>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.25139 = D.24647 + 11;
        iftmp.64 = __builtin_strcmp (D.25139, "core-clr-test");
        <D.26257>:
        D.24007 = iftmp.64;
      }
      if (D.24007 == 0) goto <D.26258>; else goto <D.26259>;
      <D.26258>:
      mono_security_set_mode (1);
      mono_security_core_clr_test = 1;
      goto <D.26260>;
      <D.26259>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 3;
        if (__s2_len <= 3) goto <D.26262>; else goto <D.26263>;
        <D.26262>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 11;
          D.26264 = "cas";
          D.26265 = MEM[(const unsigned char *)D.26264];
          D.26266 = (int) D.26265;
          D.26267 = *__s2;
          D.26268 = (int) D.26267;
          __result = D.26266 - D.26268;
          {
            D.26269 = __s2_len != 0;
            D.26270 = __result == 0;
            D.26271 = D.26269 & D.26270;
            if (D.26271 != 0) goto <D.26272>; else goto <D.26273>;
            <D.26272>:
            D.26274 = &MEM[(void *)"cas" + 1B];
            D.26275 = *D.26274;
            D.26276 = (int) D.26275;
            D.26277 = __s2 + 1;
            D.26278 = *D.26277;
            D.26279 = (int) D.26278;
            __result = D.26276 - D.26279;
            D.26280 = __s2_len > 1;
            D.26270 = __result == 0;
            D.26281 = D.26280 & D.26270;
            if (D.26281 != 0) goto <D.26282>; else goto <D.26283>;
            <D.26282>:
            D.26284 = &MEM[(void *)"cas" + 2B];
            D.26285 = *D.26284;
            D.26286 = (int) D.26285;
            D.26287 = __s2 + 2;
            D.26288 = *D.26287;
            D.26289 = (int) D.26288;
            __result = D.26286 - D.26289;
            D.26290 = __s2_len > 2;
            D.26270 = __result == 0;
            D.26291 = D.26290 & D.26270;
            if (D.26291 != 0) goto <D.26292>; else goto <D.26293>;
            <D.26292>:
            D.26294 = &MEM[(void *)"cas" + 3B];
            D.26295 = *D.26294;
            D.26296 = (int) D.26295;
            D.26297 = __s2 + 3;
            D.26298 = *D.26297;
            D.26299 = (int) D.26298;
            __result = D.26296 - D.26299;
            <D.26293>:
            <D.26283>:
            <D.26273>:
          }
          D.24015 = __result;
        }
        iftmp.65 = -D.24015;
        goto <D.26300>;
        <D.26263>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.25139 = D.24647 + 11;
        iftmp.65 = __builtin_strcmp (D.25139, "cas");
        <D.26300>:
        D.24016 = iftmp.65;
      }
      if (D.24016 == 0) goto <D.26301>; else goto <D.26302>;
      <D.26301>:
      mono_verifier_set_mode (2);
      mono_security_set_mode (2);
      mono_activate_security_manager ();
      goto <D.26303>;
      <D.26302>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.26305>; else goto <D.26306>;
        <D.26305>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 11;
          D.26307 = "validil";
          D.26308 = MEM[(const unsigned char *)D.26307];
          D.26309 = (int) D.26308;
          D.26310 = *__s2;
          D.26311 = (int) D.26310;
          __result = D.26309 - D.26311;
          {
            D.26312 = __s2_len != 0;
            D.26313 = __result == 0;
            D.26314 = D.26312 & D.26313;
            if (D.26314 != 0) goto <D.26315>; else goto <D.26316>;
            <D.26315>:
            D.26317 = &MEM[(void *)"validil" + 1B];
            D.26318 = *D.26317;
            D.26319 = (int) D.26318;
            D.26320 = __s2 + 1;
            D.26321 = *D.26320;
            D.26322 = (int) D.26321;
            __result = D.26319 - D.26322;
            D.26323 = __s2_len > 1;
            D.26313 = __result == 0;
            D.26324 = D.26323 & D.26313;
            if (D.26324 != 0) goto <D.26325>; else goto <D.26326>;
            <D.26325>:
            D.26327 = &MEM[(void *)"validil" + 2B];
            D.26328 = *D.26327;
            D.26329 = (int) D.26328;
            D.26330 = __s2 + 2;
            D.26331 = *D.26330;
            D.26332 = (int) D.26331;
            __result = D.26329 - D.26332;
            D.26333 = __s2_len > 2;
            D.26313 = __result == 0;
            D.26334 = D.26333 & D.26313;
            if (D.26334 != 0) goto <D.26335>; else goto <D.26336>;
            <D.26335>:
            D.26337 = &MEM[(void *)"validil" + 3B];
            D.26338 = *D.26337;
            D.26339 = (int) D.26338;
            D.26340 = __s2 + 3;
            D.26341 = *D.26340;
            D.26342 = (int) D.26341;
            __result = D.26339 - D.26342;
            <D.26336>:
            <D.26326>:
            <D.26316>:
          }
          D.24024 = __result;
        }
        iftmp.66 = -D.24024;
        goto <D.26343>;
        <D.26306>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.25139 = D.24647 + 11;
        iftmp.66 = __builtin_strcmp (D.25139, "validil");
        <D.26343>:
        D.24025 = iftmp.66;
      }
      if (D.24025 == 0) goto <D.26344>; else goto <D.26345>;
      <D.26344>:
      mono_verifier_set_mode (1);
      goto <D.26346>;
      <D.26345>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 10;
        if (__s2_len <= 3) goto <D.26348>; else goto <D.26349>;
        <D.26348>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 11;
          D.26350 = "verifiable";
          D.26351 = MEM[(const unsigned char *)D.26350];
          D.26352 = (int) D.26351;
          D.26353 = *__s2;
          D.26354 = (int) D.26353;
          __result = D.26352 - D.26354;
          {
            D.26355 = __s2_len != 0;
            D.26356 = __result == 0;
            D.26357 = D.26355 & D.26356;
            if (D.26357 != 0) goto <D.26358>; else goto <D.26359>;
            <D.26358>:
            D.26360 = &MEM[(void *)"verifiable" + 1B];
            D.26361 = *D.26360;
            D.26362 = (int) D.26361;
            D.26363 = __s2 + 1;
            D.26364 = *D.26363;
            D.26365 = (int) D.26364;
            __result = D.26362 - D.26365;
            D.26366 = __s2_len > 1;
            D.26356 = __result == 0;
            D.26367 = D.26366 & D.26356;
            if (D.26367 != 0) goto <D.26368>; else goto <D.26369>;
            <D.26368>:
            D.26370 = &MEM[(void *)"verifiable" + 2B];
            D.26371 = *D.26370;
            D.26372 = (int) D.26371;
            D.26373 = __s2 + 2;
            D.26374 = *D.26373;
            D.26375 = (int) D.26374;
            __result = D.26372 - D.26375;
            D.26376 = __s2_len > 2;
            D.26356 = __result == 0;
            D.26377 = D.26376 & D.26356;
            if (D.26377 != 0) goto <D.26378>; else goto <D.26379>;
            <D.26378>:
            D.26380 = &MEM[(void *)"verifiable" + 3B];
            D.26381 = *D.26380;
            D.26382 = (int) D.26381;
            D.26383 = __s2 + 3;
            D.26384 = *D.26383;
            D.26385 = (int) D.26384;
            __result = D.26382 - D.26385;
            <D.26379>:
            <D.26369>:
            <D.26359>:
          }
          D.24033 = __result;
        }
        iftmp.67 = -D.24033;
        goto <D.26386>;
        <D.26349>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.25139 = D.24647 + 11;
        iftmp.67 = __builtin_strcmp (D.25139, "verifiable");
        <D.26386>:
        D.24034 = iftmp.67;
      }
      if (D.24034 == 0) goto <D.26387>; else goto <D.26388>;
      <D.26387>:
      mono_verifier_set_mode (2);
      goto <D.26389>;
      <D.26388>:
      stderr.33 = stderr;
      fprintf (stderr.33, "error: --security= option has invalid argument (cas, core-clr, verifiable or validil)\n");
      D.24875 = 1;
      return D.24875;
      <D.26389>:
      <D.26346>:
      <D.26303>:
      <D.26260>:
      <D.26217>:
      <D.26174>:
      goto <D.26390>;
      <D.26131>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 9;
        if (__s2_len <= 3) goto <D.26392>; else goto <D.26393>;
        <D.26392>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26394 = "--desktop";
          D.26395 = MEM[(const unsigned char *)D.26394];
          D.26396 = (int) D.26395;
          D.26397 = *__s2;
          D.26398 = (int) D.26397;
          __result = D.26396 - D.26398;
          {
            D.26399 = __s2_len != 0;
            D.26400 = __result == 0;
            D.26401 = D.26399 & D.26400;
            if (D.26401 != 0) goto <D.26402>; else goto <D.26403>;
            <D.26402>:
            D.26404 = &MEM[(void *)"--desktop" + 1B];
            D.26405 = *D.26404;
            D.26406 = (int) D.26405;
            D.26407 = __s2 + 1;
            D.26408 = *D.26407;
            D.26409 = (int) D.26408;
            __result = D.26406 - D.26409;
            D.26410 = __s2_len > 1;
            D.26400 = __result == 0;
            D.26411 = D.26410 & D.26400;
            if (D.26411 != 0) goto <D.26412>; else goto <D.26413>;
            <D.26412>:
            D.26414 = &MEM[(void *)"--desktop" + 2B];
            D.26415 = *D.26414;
            D.26416 = (int) D.26415;
            D.26417 = __s2 + 2;
            D.26418 = *D.26417;
            D.26419 = (int) D.26418;
            __result = D.26416 - D.26419;
            D.26420 = __s2_len > 2;
            D.26400 = __result == 0;
            D.26421 = D.26420 & D.26400;
            if (D.26421 != 0) goto <D.26422>; else goto <D.26423>;
            <D.26422>:
            D.26424 = &MEM[(void *)"--desktop" + 3B];
            D.26425 = *D.26424;
            D.26426 = (int) D.26425;
            D.26427 = __s2 + 3;
            D.26428 = *D.26427;
            D.26429 = (int) D.26428;
            __result = D.26426 - D.26429;
            <D.26423>:
            <D.26413>:
            <D.26403>:
          }
          D.24042 = __result;
        }
        iftmp.68 = -D.24042;
        goto <D.26430>;
        <D.26393>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.68 = __builtin_strcmp (D.24647, "--desktop");
        <D.26430>:
        D.24043 = iftmp.68;
      }
      if (D.24043 == 0) goto <D.26431>; else goto <D.26432>;
      <D.26431>:
      mono_gc_set_desktop_mode ();
      goto <D.26433>;
      <D.26432>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.26435>; else goto <D.26436>;
        <D.26435>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26437 = "--server";
          D.26438 = MEM[(const unsigned char *)D.26437];
          D.26439 = (int) D.26438;
          D.26440 = *__s2;
          D.26441 = (int) D.26440;
          __result = D.26439 - D.26441;
          {
            D.26442 = __s2_len != 0;
            D.26443 = __result == 0;
            D.26444 = D.26442 & D.26443;
            if (D.26444 != 0) goto <D.26445>; else goto <D.26446>;
            <D.26445>:
            D.26447 = &MEM[(void *)"--server" + 1B];
            D.26448 = *D.26447;
            D.26449 = (int) D.26448;
            D.26450 = __s2 + 1;
            D.26451 = *D.26450;
            D.26452 = (int) D.26451;
            __result = D.26449 - D.26452;
            D.26453 = __s2_len > 1;
            D.26443 = __result == 0;
            D.26454 = D.26453 & D.26443;
            if (D.26454 != 0) goto <D.26455>; else goto <D.26456>;
            <D.26455>:
            D.26457 = &MEM[(void *)"--server" + 2B];
            D.26458 = *D.26457;
            D.26459 = (int) D.26458;
            D.26460 = __s2 + 2;
            D.26461 = *D.26460;
            D.26462 = (int) D.26461;
            __result = D.26459 - D.26462;
            D.26463 = __s2_len > 2;
            D.26443 = __result == 0;
            D.26464 = D.26463 & D.26443;
            if (D.26464 != 0) goto <D.26465>; else goto <D.26466>;
            <D.26465>:
            D.26467 = &MEM[(void *)"--server" + 3B];
            D.26468 = *D.26467;
            D.26469 = (int) D.26468;
            D.26470 = __s2 + 3;
            D.26471 = *D.26470;
            D.26472 = (int) D.26471;
            __result = D.26469 - D.26472;
            <D.26466>:
            <D.26456>:
            <D.26446>:
          }
          D.24051 = __result;
        }
        iftmp.69 = -D.24051;
        goto <D.26473>;
        <D.26436>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.69 = __builtin_strcmp (D.24647, "--server");
        <D.26473>:
        D.24052 = iftmp.69;
      }
      if (D.24052 == 0) goto <D.26474>; else goto <D.26475>;
      <D.26474>:
      mono_config_set_server_mode (1);
      goto <D.26476>;
      <D.26475>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.26478>; else goto <D.26479>;
        <D.26478>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26480 = "--inside-mdb";
          D.26481 = MEM[(const unsigned char *)D.26480];
          D.26482 = (int) D.26481;
          D.26483 = *__s2;
          D.26484 = (int) D.26483;
          __result = D.26482 - D.26484;
          {
            D.26485 = __s2_len != 0;
            D.26486 = __result == 0;
            D.26487 = D.26485 & D.26486;
            if (D.26487 != 0) goto <D.26488>; else goto <D.26489>;
            <D.26488>:
            D.26490 = &MEM[(void *)"--inside-mdb" + 1B];
            D.26491 = *D.26490;
            D.26492 = (int) D.26491;
            D.26493 = __s2 + 1;
            D.26494 = *D.26493;
            D.26495 = (int) D.26494;
            __result = D.26492 - D.26495;
            D.26496 = __s2_len > 1;
            D.26486 = __result == 0;
            D.26497 = D.26496 & D.26486;
            if (D.26497 != 0) goto <D.26498>; else goto <D.26499>;
            <D.26498>:
            D.26500 = &MEM[(void *)"--inside-mdb" + 2B];
            D.26501 = *D.26500;
            D.26502 = (int) D.26501;
            D.26503 = __s2 + 2;
            D.26504 = *D.26503;
            D.26505 = (int) D.26504;
            __result = D.26502 - D.26505;
            D.26506 = __s2_len > 2;
            D.26486 = __result == 0;
            D.26507 = D.26506 & D.26486;
            if (D.26507 != 0) goto <D.26508>; else goto <D.26509>;
            <D.26508>:
            D.26510 = &MEM[(void *)"--inside-mdb" + 3B];
            D.26511 = *D.26510;
            D.26512 = (int) D.26511;
            D.26513 = __s2 + 3;
            D.26514 = *D.26513;
            D.26515 = (int) D.26514;
            __result = D.26512 - D.26515;
            <D.26509>:
            <D.26499>:
            <D.26489>:
          }
          D.24060 = __result;
        }
        iftmp.70 = -D.24060;
        goto <D.26516>;
        <D.26479>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.70 = __builtin_strcmp (D.24647, "--inside-mdb");
        <D.26516>:
        D.24061 = iftmp.70;
      }
      if (D.24061 == 0) goto <D.26517>; else goto <D.26518>;
      <D.26517>:
      action = 6;
      goto <D.26519>;
      <D.26518>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      D.26520 = strncmp (D.24647, "--wapi=", 7);
      if (D.26520 == 0) goto <D.26521>; else goto <D.26522>;
      <D.26521>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 3;
        if (__s2_len <= 3) goto <D.26524>; else goto <D.26525>;
        <D.26524>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 7;
          D.26526 = "hps";
          D.26527 = MEM[(const unsigned char *)D.26526];
          D.26528 = (int) D.26527;
          D.26529 = *__s2;
          D.26530 = (int) D.26529;
          __result = D.26528 - D.26530;
          {
            D.26531 = __s2_len != 0;
            D.26532 = __result == 0;
            D.26533 = D.26531 & D.26532;
            if (D.26533 != 0) goto <D.26534>; else goto <D.26535>;
            <D.26534>:
            D.26536 = &MEM[(void *)"hps" + 1B];
            D.26537 = *D.26536;
            D.26538 = (int) D.26537;
            D.26539 = __s2 + 1;
            D.26540 = *D.26539;
            D.26541 = (int) D.26540;
            __result = D.26538 - D.26541;
            D.26542 = __s2_len > 1;
            D.26532 = __result == 0;
            D.26543 = D.26542 & D.26532;
            if (D.26543 != 0) goto <D.26544>; else goto <D.26545>;
            <D.26544>:
            D.26546 = &MEM[(void *)"hps" + 2B];
            D.26547 = *D.26546;
            D.26548 = (int) D.26547;
            D.26549 = __s2 + 2;
            D.26550 = *D.26549;
            D.26551 = (int) D.26550;
            __result = D.26548 - D.26551;
            D.26552 = __s2_len > 2;
            D.26532 = __result == 0;
            D.26553 = D.26552 & D.26532;
            if (D.26553 != 0) goto <D.26554>; else goto <D.26555>;
            <D.26554>:
            D.26556 = &MEM[(void *)"hps" + 3B];
            D.26557 = *D.26556;
            D.26558 = (int) D.26557;
            D.26559 = __s2 + 3;
            D.26560 = *D.26559;
            D.26561 = (int) D.26560;
            __result = D.26558 - D.26561;
            <D.26555>:
            <D.26545>:
            <D.26535>:
          }
          D.24078 = __result;
        }
        iftmp.71 = -D.24078;
        goto <D.26562>;
        <D.26525>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.26563 = D.24647 + 7;
        iftmp.71 = __builtin_strcmp (D.26563, "hps");
        <D.26562>:
        D.24079 = iftmp.71;
      }
      if (D.24079 == 0) goto <D.26564>; else goto <D.26565>;
      <D.26564>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.26566 = argc - i;
      D.24875 = mini_wapi_hps (D.26566, D.24646);
      return D.24875;
      <D.26565>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.26568>; else goto <D.26569>;
        <D.26568>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 7;
          D.26570 = "semdel";
          D.26571 = MEM[(const unsigned char *)D.26570];
          D.26572 = (int) D.26571;
          D.26573 = *__s2;
          D.26574 = (int) D.26573;
          __result = D.26572 - D.26574;
          {
            D.26575 = __s2_len != 0;
            D.26576 = __result == 0;
            D.26577 = D.26575 & D.26576;
            if (D.26577 != 0) goto <D.26578>; else goto <D.26579>;
            <D.26578>:
            D.26580 = &MEM[(void *)"semdel" + 1B];
            D.26581 = *D.26580;
            D.26582 = (int) D.26581;
            D.26583 = __s2 + 1;
            D.26584 = *D.26583;
            D.26585 = (int) D.26584;
            __result = D.26582 - D.26585;
            D.26586 = __s2_len > 1;
            D.26576 = __result == 0;
            D.26587 = D.26586 & D.26576;
            if (D.26587 != 0) goto <D.26588>; else goto <D.26589>;
            <D.26588>:
            D.26590 = &MEM[(void *)"semdel" + 2B];
            D.26591 = *D.26590;
            D.26592 = (int) D.26591;
            D.26593 = __s2 + 2;
            D.26594 = *D.26593;
            D.26595 = (int) D.26594;
            __result = D.26592 - D.26595;
            D.26596 = __s2_len > 2;
            D.26576 = __result == 0;
            D.26597 = D.26596 & D.26576;
            if (D.26597 != 0) goto <D.26598>; else goto <D.26599>;
            <D.26598>:
            D.26600 = &MEM[(void *)"semdel" + 3B];
            D.26601 = *D.26600;
            D.26602 = (int) D.26601;
            D.26603 = __s2 + 3;
            D.26604 = *D.26603;
            D.26605 = (int) D.26604;
            __result = D.26602 - D.26605;
            <D.26599>:
            <D.26589>:
            <D.26579>:
          }
          D.24087 = __result;
        }
        iftmp.72 = -D.24087;
        goto <D.26606>;
        <D.26569>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.26563 = D.24647 + 7;
        iftmp.72 = __builtin_strcmp (D.26563, "semdel");
        <D.26606>:
        D.24088 = iftmp.72;
      }
      if (D.24088 == 0) goto <D.26607>; else goto <D.26608>;
      <D.26607>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.26566 = argc - i;
      D.24875 = mini_wapi_semdel (D.26566, D.24646);
      return D.24875;
      <D.26608>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.26610>; else goto <D.26611>;
        <D.26610>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          D.24647 = *D.24646;
          __s2 = D.24647 + 7;
          D.26612 = "seminfo";
          D.26613 = MEM[(const unsigned char *)D.26612];
          D.26614 = (int) D.26613;
          D.26615 = *__s2;
          D.26616 = (int) D.26615;
          __result = D.26614 - D.26616;
          {
            D.26617 = __s2_len != 0;
            D.26618 = __result == 0;
            D.26619 = D.26617 & D.26618;
            if (D.26619 != 0) goto <D.26620>; else goto <D.26621>;
            <D.26620>:
            D.26622 = &MEM[(void *)"seminfo" + 1B];
            D.26623 = *D.26622;
            D.26624 = (int) D.26623;
            D.26625 = __s2 + 1;
            D.26626 = *D.26625;
            D.26627 = (int) D.26626;
            __result = D.26624 - D.26627;
            D.26628 = __s2_len > 1;
            D.26618 = __result == 0;
            D.26629 = D.26628 & D.26618;
            if (D.26629 != 0) goto <D.26630>; else goto <D.26631>;
            <D.26630>:
            D.26632 = &MEM[(void *)"seminfo" + 2B];
            D.26633 = *D.26632;
            D.26634 = (int) D.26633;
            D.26635 = __s2 + 2;
            D.26636 = *D.26635;
            D.26637 = (int) D.26636;
            __result = D.26634 - D.26637;
            D.26638 = __s2_len > 2;
            D.26618 = __result == 0;
            D.26639 = D.26638 & D.26618;
            if (D.26639 != 0) goto <D.26640>; else goto <D.26641>;
            <D.26640>:
            D.26642 = &MEM[(void *)"seminfo" + 3B];
            D.26643 = *D.26642;
            D.26644 = (int) D.26643;
            D.26645 = __s2 + 3;
            D.26646 = *D.26645;
            D.26647 = (int) D.26646;
            __result = D.26644 - D.26647;
            <D.26641>:
            <D.26631>:
            <D.26621>:
          }
          D.24096 = __result;
        }
        iftmp.73 = -D.24096;
        goto <D.26648>;
        <D.26611>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        D.26563 = D.24647 + 7;
        iftmp.73 = __builtin_strcmp (D.26563, "seminfo");
        <D.26648>:
        D.24097 = iftmp.73;
      }
      if (D.24097 == 0) goto <D.26649>; else goto <D.26650>;
      <D.26649>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.26566 = argc - i;
      D.24875 = mini_wapi_seminfo (D.26566, D.24646);
      return D.24875;
      <D.26650>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      stderr.33 = stderr;
      fprintf (stderr.33, "Invalid --wapi suboption: \'%s\'\n", D.24647);
      D.24875 = 1;
      return D.24875;
      <D.26522>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 20;
        if (__s2_len <= 3) goto <D.26652>; else goto <D.26653>;
        <D.26652>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26654 = "--no-x86-stack-align";
          D.26655 = MEM[(const unsigned char *)D.26654];
          D.26656 = (int) D.26655;
          D.26657 = *__s2;
          D.26658 = (int) D.26657;
          __result = D.26656 - D.26658;
          {
            D.26659 = __s2_len != 0;
            D.26660 = __result == 0;
            D.26661 = D.26659 & D.26660;
            if (D.26661 != 0) goto <D.26662>; else goto <D.26663>;
            <D.26662>:
            D.26664 = &MEM[(void *)"--no-x86-stack-align" + 1B];
            D.26665 = *D.26664;
            D.26666 = (int) D.26665;
            D.26667 = __s2 + 1;
            D.26668 = *D.26667;
            D.26669 = (int) D.26668;
            __result = D.26666 - D.26669;
            D.26670 = __s2_len > 1;
            D.26660 = __result == 0;
            D.26671 = D.26670 & D.26660;
            if (D.26671 != 0) goto <D.26672>; else goto <D.26673>;
            <D.26672>:
            D.26674 = &MEM[(void *)"--no-x86-stack-align" + 2B];
            D.26675 = *D.26674;
            D.26676 = (int) D.26675;
            D.26677 = __s2 + 2;
            D.26678 = *D.26677;
            D.26679 = (int) D.26678;
            __result = D.26676 - D.26679;
            D.26680 = __s2_len > 2;
            D.26660 = __result == 0;
            D.26681 = D.26680 & D.26660;
            if (D.26681 != 0) goto <D.26682>; else goto <D.26683>;
            <D.26682>:
            D.26684 = &MEM[(void *)"--no-x86-stack-align" + 3B];
            D.26685 = *D.26684;
            D.26686 = (int) D.26685;
            D.26687 = __s2 + 3;
            D.26688 = *D.26687;
            D.26689 = (int) D.26688;
            __result = D.26686 - D.26689;
            <D.26683>:
            <D.26673>:
            <D.26663>:
          }
          D.24105 = __result;
        }
        iftmp.74 = -D.24105;
        goto <D.26690>;
        <D.26653>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.74 = __builtin_strcmp (D.24647, "--no-x86-stack-align");
        <D.26690>:
        D.24106 = iftmp.74;
      }
      if (D.24106 == 0) goto <D.26691>; else goto <D.26692>;
      <D.26691>:
      mono_do_x86_stack_align = 0;
      goto <D.26693>;
      <D.26692>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.26695>; else goto <D.26696>;
        <D.26695>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26697 = "--llvm";
          D.26698 = MEM[(const unsigned char *)D.26697];
          D.26699 = (int) D.26698;
          D.26700 = *__s2;
          D.26701 = (int) D.26700;
          __result = D.26699 - D.26701;
          {
            D.26702 = __s2_len != 0;
            D.26703 = __result == 0;
            D.26704 = D.26702 & D.26703;
            if (D.26704 != 0) goto <D.26705>; else goto <D.26706>;
            <D.26705>:
            D.26707 = &MEM[(void *)"--llvm" + 1B];
            D.26708 = *D.26707;
            D.26709 = (int) D.26708;
            D.26710 = __s2 + 1;
            D.26711 = *D.26710;
            D.26712 = (int) D.26711;
            __result = D.26709 - D.26712;
            D.26713 = __s2_len > 1;
            D.26703 = __result == 0;
            D.26714 = D.26713 & D.26703;
            if (D.26714 != 0) goto <D.26715>; else goto <D.26716>;
            <D.26715>:
            D.26717 = &MEM[(void *)"--llvm" + 2B];
            D.26718 = *D.26717;
            D.26719 = (int) D.26718;
            D.26720 = __s2 + 2;
            D.26721 = *D.26720;
            D.26722 = (int) D.26721;
            __result = D.26719 - D.26722;
            D.26723 = __s2_len > 2;
            D.26703 = __result == 0;
            D.26724 = D.26723 & D.26703;
            if (D.26724 != 0) goto <D.26725>; else goto <D.26726>;
            <D.26725>:
            D.26727 = &MEM[(void *)"--llvm" + 3B];
            D.26728 = *D.26727;
            D.26729 = (int) D.26728;
            D.26730 = __s2 + 3;
            D.26731 = *D.26730;
            D.26732 = (int) D.26731;
            __result = D.26729 - D.26732;
            <D.26726>:
            <D.26716>:
            <D.26706>:
          }
          D.24114 = __result;
        }
        iftmp.75 = -D.24114;
        goto <D.26733>;
        <D.26696>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.75 = __builtin_strcmp (D.24647, "--llvm");
        <D.26733>:
        D.24115 = iftmp.75;
      }
      if (D.24115 == 0) goto <D.26734>; else goto <D.26735>;
      <D.26734>:
      stderr.33 = stderr;
      fprintf (stderr.33, "Mono Warning: --llvm not enabled in this runtime.\n");
      goto <D.26736>;
      <D.26735>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.26738>; else goto <D.26739>;
        <D.26738>:
        {
          const unsigned char * __s2;
          int __result;

          i.19 = (unsigned int) i;
          D.24645 = i.19 * 4;
          D.24646 = argv + D.24645;
          __s2 = *D.24646;
          D.26740 = "--nollvm";
          D.26741 = MEM[(const unsigned char *)D.26740];
          D.26742 = (int) D.26741;
          D.26743 = *__s2;
          D.26744 = (int) D.26743;
          __result = D.26742 - D.26744;
          {
            D.26745 = __s2_len != 0;
            D.26746 = __result == 0;
            D.26747 = D.26745 & D.26746;
            if (D.26747 != 0) goto <D.26748>; else goto <D.26749>;
            <D.26748>:
            D.26750 = &MEM[(void *)"--nollvm" + 1B];
            D.26751 = *D.26750;
            D.26752 = (int) D.26751;
            D.26753 = __s2 + 1;
            D.26754 = *D.26753;
            D.26755 = (int) D.26754;
            __result = D.26752 - D.26755;
            D.26756 = __s2_len > 1;
            D.26746 = __result == 0;
            D.26757 = D.26756 & D.26746;
            if (D.26757 != 0) goto <D.26758>; else goto <D.26759>;
            <D.26758>:
            D.26760 = &MEM[(void *)"--nollvm" + 2B];
            D.26761 = *D.26760;
            D.26762 = (int) D.26761;
            D.26763 = __s2 + 2;
            D.26764 = *D.26763;
            D.26765 = (int) D.26764;
            __result = D.26762 - D.26765;
            D.26766 = __s2_len > 2;
            D.26746 = __result == 0;
            D.26767 = D.26766 & D.26746;
            if (D.26767 != 0) goto <D.26768>; else goto <D.26769>;
            <D.26768>:
            D.26770 = &MEM[(void *)"--nollvm" + 3B];
            D.26771 = *D.26770;
            D.26772 = (int) D.26771;
            D.26773 = __s2 + 3;
            D.26774 = *D.26773;
            D.26775 = (int) D.26774;
            __result = D.26772 - D.26775;
            <D.26769>:
            <D.26759>:
            <D.26749>:
          }
          D.24123 = __result;
        }
        iftmp.76 = -D.24123;
        goto <D.26776>;
        <D.26739>:
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        D.24647 = *D.24646;
        iftmp.76 = __builtin_strcmp (D.24647, "--nollvm");
        <D.26776>:
        D.24124 = iftmp.76;
      }
      if (D.24124 == 0) goto <D.26777>; else goto <D.26778>;
      <D.26777>:
      mono_use_llvm = 0;
      goto <D.26779>;
      <D.26778>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      stderr.33 = stderr;
      fprintf (stderr.33, "Unknown command line option: \'%s\'\n", D.24647);
      D.24875 = 1;
      return D.24875;
      <D.26779>:
      <D.26736>:
      <D.26693>:
      <D.26519>:
      <D.26476>:
      <D.26433>:
      <D.26390>:
      <D.26128>:
      <D.26085>:
      <D.26080>:
      <D.26073>:
      <D.26030>:
      <D.25985>:
      <D.25978>:
      <D.25933>:
      <D.25929>:
      <D.25922>:
      <D.25918>:
      <D.25875>:
      <D.25832>:
      <D.25828>:
      <D.25785>:
      <D.25779>:
      <D.25775>:
      <D.25732>:
      <D.25689>:
      <D.25646>:
      <D.25603>:
      <D.25560>:
      <D.25510>:
      <D.25459>:
      <D.25411>:
      <D.25368>:
      <D.25364>:
      <D.25321>:
      <D.25276>:
      <D.25231>:
      <D.25188>:
      <D.25145>:
      <D.25140>:
      <D.25135>:
      <D.24701>:
      <D.24698>:
      <D.24692>:
      i = i + 1;
      <D.24126>:
      if (i < argc) goto <D.24125>; else goto <D.23550>;
      <D.23550>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      if (D.24647 == 0B) goto <D.26780>; else goto <D.26781>;
      <D.26780>:
      mini_usage ();
      D.24875 = 1;
      return D.24875;
      <D.26781>:
      D.26782 = monoeg_g_getenv ("MONO_XDEBUG");
      if (D.26782 != 0B) goto <D.26783>; else goto <D.26784>;
      <D.26783>:
      enable_debugging = 1;
      <D.26784>:
      mono_compile_aot.77 = mono_compile_aot;
      if (mono_compile_aot.77 != 0) goto <D.26785>; else goto <D.26788>;
      <D.26788>:
      D.26789 = action == 4;
      D.26790 = action == 6;
      D.26791 = D.26789 | D.26790;
      if (D.26791 != 0) goto <D.26785>; else goto <D.26786>;
      <D.26785>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      monoeg_g_set_prgname (D.24647);
      <D.26786>:
      if (enable_profile != 0) goto <D.26792>; else goto <D.26793>;
      <D.26792>:
      mono_profiler_load (profile_options);
      <D.26793>:
      mono_attach_parse_options (attach_options);
      if (trace_options != 0B) goto <D.26794>; else goto <D.26795>;
      <D.26794>:
      mono_jit_trace_calls.78 = mono_trace_parse_options (trace_options);
      mono_jit_trace_calls = mono_jit_trace_calls.78;
      mono_jit_trace_calls.79 = mono_jit_trace_calls;
      if (mono_jit_trace_calls.79 == 0B) goto <D.26798>; else goto <D.26799>;
      <D.26798>:
      exit (1);
      <D.26799>:
      <D.26795>:
      if (action == 6) goto <D.26800>; else goto <D.26801>;
      <D.26800>:
      enable_debugging = 1;
      monoeg_g_print ("The Mono Debugger is no longer supported.\n");
      D.24875 = 1;
      return D.24875;
      <D.26801>:
      enable_debugging.80 = enable_debugging;
      if (enable_debugging.80 != 0) goto <D.26803>; else goto <D.26804>;
      <D.26803>:
      mono_debug_init (1);
      <D.26804>:
      mono_set_defaults (mini_verbose, opt);
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.24647 = *D.24646;
      domain.81 = mini_init (D.24647, forced_version);
      domain = domain.81;
      mono_gc_set_stack_end (&domain);
      if (agents != 0B) goto <D.26806>; else goto <D.26807>;
      <D.26806>:
      {
        int i;

        i = 0;
        goto <D.24130>;
        <D.24129>:
        {
          int res;

          D.26808 = agents->pdata;
          i.82 = (unsigned int) i;
          D.26810 = i.82 * 4;
          D.26811 = D.26808 + D.26810;
          D.26812 = *D.26811;
          domain.83 = domain;
          res = load_agent (domain.83, D.26812);
          if (res != 0) goto <D.26814>; else goto <D.26815>;
          <D.26814>:
          monoeg_g_ptr_array_free (agents, 1);
          domain.83 = domain;
          mini_cleanup (domain.83);
          D.24875 = 1;
          return D.24875;
          <D.26815>:
        }
        i = i + 1;
        <D.24130>:
        i.84 = (unsigned int) i;
        D.26817 = agents->len;
        if (i.84 < D.26817) goto <D.24129>; else goto <D.24131>;
        <D.24131>:
        monoeg_g_ptr_array_free (agents, 1);
      }
      <D.26807>:
      switch (action) <default: <D.24138>, case 0: <D.24134>, case 1: <D.24133>, case 2: <D.24132>, case 3: <D.24136>, case 5: <D.24137>>
      <D.24132>:
      mono_do_single_method_regression = 1;
      <D.24133>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      D.26566 = argc - i;
      D.26818 = mini_regression_list (mini_verbose, D.26566, D.24646);
      if (D.26818 != 0) goto <D.26819>; else goto <D.26820>;
      <D.26819>:
      monoeg_g_print ("Regression ERRORS!\n");
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 1;
      return D.24875;
      <D.26820>:
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 0;
      return D.24875;
      <D.24134>:
      D.26566 = argc - i;
      if (D.26566 != 1) goto <D.26821>; else goto <D.26823>;
      <D.26823>:
      if (mname == 0B) goto <D.26821>; else goto <D.26822>;
      <D.26821>:
      monoeg_g_print ("Usage: mini --ncompile num --compile method assembly\n");
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 1;
      return D.24875;
      <D.26822>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      aname = *D.24646;
      goto <D.24135>;
      <D.24136>:
      D.26566 = argc - i;
      if (D.26566 != 1) goto <D.26824>; else goto <D.26825>;
      <D.26824>:
      mini_usage ();
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 1;
      return D.24875;
      <D.26825>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      aname = *D.24646;
      goto <D.24135>;
      <D.24137>:
      D.26566 = argc - i;
      if (D.26566 != 1) goto <D.26826>; else goto <D.26828>;
      <D.26828>:
      if (mname == 0B) goto <D.26826>; else goto <D.26827>;
      <D.26826>:
      mini_usage ();
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 1;
      return D.24875;
      <D.26827>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      aname = *D.24646;
      goto <D.24135>;
      <D.24138>:
      D.26566 = argc - i;
      if (D.26566 <= 0) goto <D.26829>; else goto <D.26830>;
      <D.26829>:
      mini_usage ();
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 1;
      return D.24875;
      <D.26830>:
      i.19 = (unsigned int) i;
      D.24645 = i.19 * 4;
      D.24646 = argv + D.24645;
      aname = *D.24646;
      goto <D.24135>;
      <D.24135>:
      mono_compile_aot.77 = mono_compile_aot;
      if (mono_compile_aot.77 != 0) goto <D.26831>; else goto <D.26833>;
      <D.26833>:
      D.26789 = action == 4;
      D.26790 = action == 6;
      D.26791 = D.26789 | D.26790;
      if (D.26791 != 0) goto <D.26831>; else goto <D.26832>;
      <D.26831>:
      mono_config_parse (config_file);
      <D.26832>:
      assembly = mono_assembly_open (aname, &open_status);
      if (assembly == 0B) goto <D.26834>; else goto <D.26835>;
      <D.26834>:
      open_status.85 = open_status;
      D.26837 = mono_image_strerror (open_status.85);
      stderr.33 = stderr;
      fprintf (stderr.33, "Cannot open assembly \'%s\': %s.\n", aname, D.26837);
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 2;
      return D.24875;
      <D.26835>:
      if (trace_options != 0B) goto <D.26838>; else goto <D.26839>;
      <D.26838>:
      mono_trace_set_assembly (assembly);
      <D.26839>:
      mono_compile_aot.77 = mono_compile_aot;
      if (mono_compile_aot.77 != 0) goto <D.26840>; else goto <D.26842>;
      <D.26842>:
      if (action == 4) goto <D.26840>; else goto <D.26841>;
      <D.26840>:
      {
        const char * error;

        error = mono_check_corlib_version ();
        if (error != 0B) goto <D.26843>; else goto <D.26844>;
        <D.26843>:
        stderr.33 = stderr;
        fprintf (stderr.33, "Corlib not in sync with this runtime: %s\n", error);
        D.24869 = mono_defaults.corlib;
        if (D.24869 != 0B) goto <D.26846>; else goto <D.26847>;
        <D.26846>:
        D.24869 = mono_defaults.corlib;
        iftmp.86 = mono_image_get_filename (D.24869);
        goto <D.26848>;
        <D.26847>:
        iftmp.86 = "unknown";
        <D.26848>:
        stderr.33 = stderr;
        fprintf (stderr.33, "Loaded from: %s\n", iftmp.86);
        stderr.33 = stderr;
        fprintf (stderr.33, "Download a newer corlib or a newer runtime at http://www.go-mono.com/daily.\n");
        exit (1);
        <D.26844>:
        domain.83 = domain;
        main_args.domain = domain.83;
        main_args.file = aname;
        D.26566 = argc - i;
        main_args.argc = D.26566;
        i.19 = (unsigned int) i;
        D.24645 = i.19 * 4;
        D.24646 = argv + D.24645;
        main_args.argv = D.24646;
        main_args.opts = opt;
        main_args.aot_options = aot_options;
        main_thread_handler (&main_args);
        mono_thread_manage ();
        mono_dont_free_global_codeman = 1;
        domain.83 = domain;
        mini_cleanup (domain.83);
        i = mono_environment_exitcode_get ();
        D.24875 = i;
        return D.24875;
      }
      <D.26841>:
      if (action == 3) goto <D.26849>; else goto <D.26850>;
      <D.26849>:
      compile_all_methods (assembly, mini_verbose, opt, recompilation_times);
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 0;
      return D.24875;
      <D.26850>:
      if (action == 6) goto <D.26851>; else goto <D.26852>;
      <D.26851>:
      D.24875 = 1;
      return D.24875;
      <D.26852>:
      desc = mono_method_desc_new (mname, 0);
      if (desc == 0B) goto <D.26853>; else goto <D.26854>;
      <D.26853>:
      monoeg_g_print ("Invalid method name %s\n", mname);
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 3;
      return D.24875;
      <D.26854>:
      D.26855 = mono_assembly_get_image (assembly);
      method = mono_method_desc_search_in_image (desc, D.26855);
      if (method == 0B) goto <D.26856>; else goto <D.26857>;
      <D.26856>:
      monoeg_g_print ("Cannot find method %s\n", mname);
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 3;
      return D.24875;
      <D.26857>:
      if (action == 5) goto <D.26858>; else goto <D.26859>;
      <D.26858>:
      {
        int part;

        part = 0;
        switch (mono_graph_options) <default: <D.24146>, case 2: <D.24141>, case 4: <D.24143>, case 8: <D.24144>, case 16: <D.24145>>
        <D.24141>:
        part = 1;
        opt = opt | 8192;
        goto <D.24142>;
        <D.24143>:
        part = 1;
        goto <D.24142>;
        <D.24144>:
        part = 2;
        goto <D.24142>;
        <D.24145>:
        part = 3;
        goto <D.24142>;
        <D.24146>:
        goto <D.24142>;
        <D.24142>:
        D.26863 = method->iflags;
        D.26864 = (int) D.26863;
        D.26865 = D.26864 & 4096;
        if (D.26865 != 0) goto <D.26860>; else goto <D.26866>;
        <D.26866>:
        D.26867 = method->flags;
        D.26868 = (int) D.26867;
        D.26869 = D.26868 & 8192;
        if (D.26869 != 0) goto <D.26860>; else goto <D.26861>;
        <D.26860>:
        {
          struct MonoMethod * nm;

          nm = mono_marshal_get_native_wrapper (method, 1, 0);
          D.26870 = mono_get_root_domain ();
          cfg = mini_method_compile (nm, opt, D.26870, 0, part);
        }
        goto <D.26862>;
        <D.26861>:
        D.26871 = mono_get_root_domain ();
        cfg = mini_method_compile (method, opt, D.26871, 0, part);
        <D.26862>:
        D.26872 = mono_graph_options & 8;
        if (D.26872 != 0) goto <D.26873>; else goto <D.26874>;
        <D.26873>:
        D.26875 = cfg->comp_done;
        D.26876 = D.26875 & 32;
        if (D.26876 == 0) goto <D.26877>; else goto <D.26878>;
        <D.26877>:
        monoeg_g_log (0B, 16, "no SSA info available (use -O=deadce)");
        D.24875 = 1;
        return D.24875;
        <D.26878>:
        <D.26874>:
        mono_draw_graph (cfg, mono_graph_options);
        mono_destroy_compile (cfg);
      }
      goto <D.26879>;
      <D.26859>:
      if (action == 0) goto <D.26880>; else goto <D.26881>;
      <D.26880>:
      mini_stats_fd.87 = mini_stats_fd;
      if (mini_stats_fd.87 != 0B) goto <D.26883>; else goto <D.26884>;
      <D.26883>:
      {
        const char * n;
        double no_opt_time;
        struct GTimer * timer;

        no_opt_time = 0.0;
        timer = monoeg_g_timer_new ();
        D.26885 = mono_method_full_name (method, 1);
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "$stattitle = \'Compilations times for %s\';\n", D.26885);
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "@data = (\n");
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "[");
        i = 0;
        goto <D.24152>;
        <D.24151>:
        opt = opt_sets[i];
        n = opt_descr (opt);
        D.26886 = *n;
        if (D.26886 == 0) goto <D.26887>; else goto <D.26888>;
        <D.26887>:
        n = "none";
        <D.26888>:
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "\"%s\",", n);
        i = i + 1;
        <D.24152>:
        i.19 = (unsigned int) i;
        if (i.19 <= 26) goto <D.24151>; else goto <D.24153>;
        <D.24153>:
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "],\n[");
        i = 0;
        goto <D.24160>;
        <D.24159>:
        {
          int j;
          double elapsed;

          opt = opt_sets[i];
          monoeg_g_timer_start (timer);
          j = 0;
          goto <D.24157>;
          <D.24156>:
          D.26889 = mono_get_root_domain ();
          cfg = mini_method_compile (method, opt, D.26889, 0, 0);
          mono_destroy_compile (cfg);
          j = j + 1;
          <D.24157>:
          if (j < count) goto <D.24156>; else goto <D.24158>;
          <D.24158>:
          monoeg_g_timer_stop (timer);
          elapsed = monoeg_g_timer_elapsed (timer, 0B);
          if (opt == 0) goto <D.26890>; else goto <D.26891>;
          <D.26890>:
          no_opt_time = elapsed;
          <D.26891>:
          mini_stats_fd.87 = mini_stats_fd;
          fprintf (mini_stats_fd.87, "%f, ", elapsed);
        }
        i = i + 1;
        <D.24160>:
        i.19 = (unsigned int) i;
        if (i.19 <= 26) goto <D.24159>; else goto <D.24161>;
        <D.24161>:
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "]");
        if (no_opt_time > 0.0) goto <D.26892>; else goto <D.26893>;
        <D.26892>:
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, ", \n[");
        i = 0;
        goto <D.24163>;
        <D.24162>:
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "%f,", no_opt_time);
        i = i + 1;
        <D.24163>:
        i.19 = (unsigned int) i;
        if (i.19 <= 26) goto <D.24162>; else goto <D.24164>;
        <D.24164>:
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, "]");
        <D.26893>:
        mini_stats_fd.87 = mini_stats_fd;
        fprintf (mini_stats_fd.87, ");\n");
      }
      goto <D.26894>;
      <D.26884>:
      i = 0;
      goto <D.24166>;
      <D.24165>:
      D.26863 = method->iflags;
      D.26864 = (int) D.26863;
      D.26865 = D.26864 & 4096;
      if (D.26865 != 0) goto <D.26895>; else goto <D.26897>;
      <D.26897>:
      D.26867 = method->flags;
      D.26868 = (int) D.26867;
      D.26869 = D.26868 & 8192;
      if (D.26869 != 0) goto <D.26895>; else goto <D.26896>;
      <D.26895>:
      method = mono_marshal_get_native_wrapper (method, 1, 0);
      <D.26896>:
      D.26898 = mono_get_root_domain ();
      cfg = mini_method_compile (method, opt, D.26898, 0, 0);
      mono_destroy_compile (cfg);
      i = i + 1;
      <D.24166>:
      if (i < count) goto <D.24165>; else goto <D.24167>;
      <D.24167>:
      <D.26894>:
      goto <D.26899>;
      <D.26881>:
      D.26900 = mono_get_root_domain ();
      cfg = mini_method_compile (method, opt, D.26900, 0, 0);
      mono_destroy_compile (cfg);
      <D.26899>:
      <D.26879>:
      domain.83 = domain;
      mini_cleanup (domain.83);
      D.24875 = 0;
      return D.24875;
    }
  finally
    {
      main_args = {CLOBBER};
      domain = {CLOBBER};
      open_status = {CLOBBER};
    }
}


mono_set_use_smp (int use_smp)
{
  int D.26906;

  if (use_smp == 0) goto <D.26904>; else goto <D.26905>;
  <D.26904>:
  {
    long unsigned int proc_mask;

    try
      {
        proc_mask = 1;
        D.26906 = getpid ();
        sched_setaffinity (D.26906, 4, &proc_mask);
      }
    finally
      {
        proc_mask = {CLOBBER};
      }
  }
  <D.26905>:
}


mini_trace_usage ()
{
  struct _IO_FILE * stdout.88;

  stdout.88 = stdout;
  fprintf (stdout.88, "Tracing options:\n   --trace[=EXPR]        Trace every call, optional EXPR controls the scope\n\nEXPR is composed of:\n    all                  All assemblies\n    none                 No assemblies\n    program              Entry point assembly\n    assembly             Specifies an assembly\n    wrapper              All wrappers bridging native and managed code\n    M:Type:Method        Specifies a method\n    N:Namespace          Specifies a namespace\n    T:Type               Specifies a type\n    E:Type               Specifies stack traces for an exception type\n    EXPR                 Includes expression\n    -EXPR                Excludes expression\n    EXPR,EXPR            Multiple expressions\n    disabled             Don\'t print any output until toggled via SIGUSR2\n");
}


mini_usage_jitdeveloper ()
{
  struct _IO_FILE * stdout.89;
  const char[18] * D.26909;
  const char[6] * D.26910;
  unsigned int i.90;
  int i;

  stdout.89 = stdout;
  fprintf (stdout.89, "Runtime and JIT debugging options:\n    --breakonex            Inserts a breakpoint on exceptions\n    --break METHOD         Inserts a breakpoint at METHOD entry\n    --break-at-bb METHOD N Inserts a breakpoint in METHOD at BB N\n    --compile METHOD       Just compile METHOD in assembly\n    --compile-all=N        Compiles all the methods in the assembly multiple times (default: 1)\n    --ncompile N           Number of times to compile METHOD (default: 1)\n    --print-vtable         Print the vtable of all used classes\n    --regression           Runs the regression test contained in the assembly\n    --single-method=OPTS   Runs regressions with only one method optimized with OPTS at any time\n    --statfile FILE        Sets the stat file to FILE\n    --stats                Print statistics about the JIT operations\n    --wapi=hps|semdel|seminfo IO-layer maintenance\n    --inject-async-exc METHOD OFFSET Inject an asynchronous exception at METHOD\n    --verify-all           Run the verifier on all assemblies and methods\n    --full-aot             Avoid JITting any code\n    --agent=ASSEMBLY[:ARG] Loads the specific agent assembly and executes its Main method with the given argument before loading the main assembly.\n    --no-x86-stack-align   Don\'t align stack on x86\n\nOther options:\n    --graph[=TYPE] METHOD  Draws a graph of the specified method:\n");
  i = 0;
  goto <D.23360>;
  <D.23359>:
  D.26909 = &graph_names[i].desc;
  D.26910 = &graph_names[i].name;
  stdout.89 = stdout;
  fprintf (stdout.89, "                           %-10s %s\n", D.26910, D.26909);
  i = i + 1;
  <D.23360>:
  i.90 = (unsigned int) i;
  if (i.90 <= 4) goto <D.23359>; else goto <D.23361>;
  <D.23361>:
}


mini_debug_usage ()
{
  struct _IO_FILE * stdout.91;

  stdout.91 = stdout;
  fprintf (stdout.91, "Debugging options:\n   --debug[=OPTIONS]     Enable debugging support, optional OPTIONS is a comma\n                         separated list of options\n\nOPTIONS is composed of:\n    casts                Enable more detailed InvalidCastException messages.\n    mdb-optimizations    Disable some JIT optimizations which are normally\n                         disabled when running inside the debugger.\n                         This is useful if you plan to attach to the running\n                         process with the debugger.\n");
}


mini_usage_list_opt ()
{
  short int D.26913;
  sizetype D.26914;
  const char * D.26915;
  unsigned int D.26916;
  sizetype D.26917;
  sizetype D.26918;
  const char * D.26919;
  struct _IO_FILE * stdout.92;
  unsigned int i.93;
  int i;

  i = 0;
  goto <D.23367>;
  <D.23366>:
  D.26913 = opt_names[i];
  D.26914 = (sizetype) D.26913;
  D.26913 = opt_names[i];
  D.26914 = (sizetype) D.26913;
  D.26915 = &opstr + D.26914;
  D.26916 = strlen (D.26915);
  D.26917 = D.26914 + D.26916;
  D.26918 = D.26917 + 1;
  D.26919 = &opstr + D.26918;
  D.26913 = opt_names[i];
  D.26914 = (sizetype) D.26913;
  D.26915 = &opstr + D.26914;
  stdout.92 = stdout;
  fprintf (stdout.92, "                           %-10s %s\n", D.26915, D.26919);
  i = i + 1;
  <D.23367>:
  i.93 = (unsigned int) i;
  if (i.93 <= 28) goto <D.23366>; else goto <D.23368>;
  <D.23368>:
}


switch_gc (char * * argv, const char * target_gc)
{
  int D.23520;
  const char * D.26922;
  char * D.26925;
  char * D.26926;
  unsigned int D.26929;
  unsigned int D.26930;
  char * D.26932;
  unsigned int D.26935;
  char * D.26936;
  struct GString * path;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.26922 = mono_gc_get_gc_name ();
    D.23520 = __builtin_strcmp (D.26922, target_gc);
  }
  if (D.23520 == 0) goto <D.26923>; else goto <D.26924>;
  <D.26923>:
  return;
  <D.26924>:
  D.26925 = *argv;
  path = monoeg_g_string_new (D.26925);
  D.26925 = *argv;
  D.26926 = strstr (D.26925, "-sgen");
  if (D.26926 != 0B) goto <D.26927>; else goto <D.26928>;
  <D.26927>:
  D.26929 = path->len;
  D.26930 = D.26929 + 4294967291;
  monoeg_g_string_truncate (path, D.26930);
  goto <D.26931>;
  <D.26928>:
  D.26925 = *argv;
  D.26932 = strstr (D.26925, "-boehm");
  if (D.26932 != 0B) goto <D.26933>; else goto <D.26934>;
  <D.26933>:
  D.26929 = path->len;
  D.26935 = D.26929 + 4294967290;
  monoeg_g_string_truncate (path, D.26935);
  <D.26934>:
  <D.26931>:
  monoeg_g_string_append_c (path, 45);
  monoeg_g_string_append (path, target_gc);
  D.26936 = path->str;
  execvp (D.26936, argv);
}


atoi (const char * __nptr)
{
  int D.26938;

  D.26938 = strtol (__nptr, 0B, 10);
  return D.26938;
}


mono_parse_graph_options (const char * p)
{
  unsigned int D.26940;
  unsigned int len.94;
  int D.26942;
  MonoGraphOptions D.26945;
  unsigned int i.95;
  struct _IO_FILE * stderr.96;
  const char * n;
  int i;
  int len;

  i = 0;
  goto <D.23149>;
  <D.23148>:
  n = &graph_names[i].name;
  D.26940 = strlen (n);
  len = (int) D.26940;
  len.94 = (unsigned int) len;
  D.26942 = strncmp (p, n, len.94);
  if (D.26942 == 0) goto <D.26943>; else goto <D.26944>;
  <D.26943>:
  D.26945 = graph_names[i].value;
  return D.26945;
  <D.26944>:
  i = i + 1;
  <D.23149>:
  i.95 = (unsigned int) i;
  if (i.95 <= 4) goto <D.23148>; else goto <D.23150>;
  <D.23150>:
  stderr.96 = stderr;
  fprintf (stderr.96, "Invalid graph name provided: %s\n", p);
  exit (1);
}


parse_debug_options (const char * p)
{
  char D.26949;
  struct _IO_FILE * stderr.97;
  gboolean D.26953;
  int D.26954;
  int D.26958;
  int D.26962;
  struct MonoDebugOptions * opt;

  opt = mini_get_debug_options ();
  <D.23125>:
  D.26949 = *p;
  if (D.26949 == 0) goto <D.26950>; else goto <D.26951>;
  <D.26950>:
  stderr.97 = stderr;
  fprintf (stderr.97, "Syntax error; expected debug option name\n");
  D.26953 = 0;
  return D.26953;
  <D.26951>:
  D.26954 = strncmp (p, "casts", 5);
  if (D.26954 == 0) goto <D.26955>; else goto <D.26956>;
  <D.26955>:
  opt->better_cast_details = 1;
  p = p + 5;
  goto <D.26957>;
  <D.26956>:
  D.26958 = strncmp (p, "mdb-optimizations", 17);
  if (D.26958 == 0) goto <D.26959>; else goto <D.26960>;
  <D.26959>:
  opt->mdb_optimizations = 1;
  p = p + 17;
  goto <D.26961>;
  <D.26960>:
  D.26962 = strncmp (p, "gdb", 3);
  if (D.26962 == 0) goto <D.26963>; else goto <D.26964>;
  <D.26963>:
  opt->gdb = 1;
  p = p + 3;
  goto <D.26965>;
  <D.26964>:
  stderr.97 = stderr;
  fprintf (stderr.97, "Invalid debug option `%s\', use --help-debug for details\n", p);
  D.26953 = 0;
  return D.26953;
  <D.26965>:
  <D.26961>:
  <D.26957>:
  D.26949 = *p;
  if (D.26949 == 44) goto <D.26966>; else goto <D.26967>;
  <D.26966>:
  p = p + 1;
  D.26949 = *p;
  if (D.26949 == 0) goto <D.26968>; else goto <D.26969>;
  <D.26968>:
  stderr.97 = stderr;
  fprintf (stderr.97, "Syntax error; expected debug option name\n");
  D.26953 = 0;
  return D.26953;
  <D.26969>:
  <D.26967>:
  D.26949 = *p;
  if (D.26949 != 0) goto <D.23125>; else goto <D.23126>;
  <D.23126>:
  D.26953 = 1;
  return D.26953;
}


load_agent (struct MonoDomain * domain, char * desc)
{
  int col.98;
  int desc.99;
  int D.26975;
  int D.26976;
  unsigned int D.26977;
  sizetype D.26978;
  char * D.26979;
  <unnamed type> open_status.100;
  const char * D.26984;
  struct _IO_FILE * stderr.101;
  int D.26986;
  const char * D.26989;
  struct MonoThread * D.26992;
  struct MonoClass * D.26995;
  struct MonoString * D.26996;
  char * col;
  char * agent;
  char * args;
  struct MonoAssembly * agent_assembly;
  struct MonoImage * image;
  struct MonoMethod * method;
  guint32 entry;
  struct MonoArray * main_args;
  void * pa[1];
  MonoImageOpenStatus open_status;

  try
    {
      col = __builtin_strchr (desc, 58);
      if (col != 0B) goto <D.26971>; else goto <D.26972>;
      <D.26971>:
      col.98 = (int) col;
      desc.99 = (int) desc;
      D.26975 = col.98 - desc.99;
      D.26976 = D.26975 + 1;
      D.26977 = (unsigned int) D.26976;
      agent = monoeg_g_memdup (desc, D.26977);
      col.98 = (int) col;
      desc.99 = (int) desc;
      D.26975 = col.98 - desc.99;
      D.26978 = (sizetype) D.26975;
      D.26979 = agent + D.26978;
      *D.26979 = 0;
      args = col + 1;
      goto <D.26980>;
      <D.26972>:
      agent = monoeg_strdup (desc);
      args = 0B;
      <D.26980>:
      agent_assembly = mono_assembly_open (agent, &open_status);
      if (agent_assembly == 0B) goto <D.26981>; else goto <D.26982>;
      <D.26981>:
      open_status.100 = open_status;
      D.26984 = mono_image_strerror (open_status.100);
      stderr.101 = stderr;
      fprintf (stderr.101, "Cannot open agent assembly \'%s\': %s.\n", agent, D.26984);
      monoeg_g_free (agent);
      D.26986 = 2;
      return D.26986;
      <D.26982>:
      image = mono_assembly_get_image (agent_assembly);
      entry = mono_image_get_entry_point (image);
      if (entry == 0) goto <D.26987>; else goto <D.26988>;
      <D.26987>:
      D.26989 = mono_image_get_filename (image);
      monoeg_g_print ("Assembly \'%s\' doesn\'t have an entry point.\n", D.26989);
      monoeg_g_free (agent);
      D.26986 = 1;
      return D.26986;
      <D.26988>:
      method = mono_get_method (image, entry, 0B);
      if (method == 0B) goto <D.26990>; else goto <D.26991>;
      <D.26990>:
      monoeg_g_print ("The entry point method of assembly \'%s\' could not be loaded\n", agent);
      monoeg_g_free (agent);
      D.26986 = 1;
      return D.26986;
      <D.26991>:
      D.26992 = mono_thread_current ();
      mono_thread_set_main (D.26992);
      if (args != 0B) goto <D.26993>; else goto <D.26994>;
      <D.26993>:
      D.26995 = mono_defaults.string_class;
      main_args = mono_array_new (domain, D.26995, 1);
      {
        struct MonoString * * __p;

        __p = mono_array_addr_with_size (main_args, 4, 0);
        D.26996 = mono_string_new (domain, args);
        *__p = D.26996;
      }
      goto <D.26997>;
      <D.26994>:
      D.26995 = mono_defaults.string_class;
      main_args = mono_array_new (domain, D.26995, 0);
      <D.26997>:
      monoeg_g_free (agent);
      pa[0] = main_args;
      mono_runtime_invoke (method, 0B, &pa, 0B);
      D.26986 = 0;
      return D.26986;
    }
  finally
    {
      pa = {CLOBBER};
      open_status = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.27000>; else goto <D.27001>;
  <D.27000>:
  D.27002 = __strdup (str);
  return D.27002;
  <D.27001>:
  D.27002 = 0B;
  return D.27002;
}


mini_regression_list (int verbose, int count, char * * images)
{
  unsigned int i.102;
  unsigned int D.27005;
  char * * D.27006;
  char * D.27007;
  struct MonoImage * D.27010;
  int D.27011;
  int run.103;
  int D.27015;
  double D.27016;
  double D.27017;
  double D.27018;
  double D.27019;
  int D.27021;
  int i;
  int total;
  int total_run;
  int run;
  struct MonoAssembly * ass;

  try
    {
      total = 0;
      total_run = total;
      i = 0;
      goto <D.23253>;
      <D.23252>:
      i.102 = (unsigned int) i;
      D.27005 = i.102 * 4;
      D.27006 = images + D.27005;
      D.27007 = *D.27006;
      ass = mono_assembly_open (D.27007, 0B);
      if (ass == 0B) goto <D.27008>; else goto <D.27009>;
      <D.27008>:
      i.102 = (unsigned int) i;
      D.27005 = i.102 * 4;
      D.27006 = images + D.27005;
      D.27007 = *D.27006;
      monoeg_g_log (0B, 16, "failed to load assembly: %s", D.27007);
      // predicted unlikely by continue predictor.
      goto <D.23251>;
      <D.27009>:
      D.27010 = mono_assembly_get_image (ass);
      D.27011 = mini_regression (D.27010, verbose, &run);
      total = D.27011 + total;
      run.103 = run;
      total_run = total_run + run.103;
      <D.23251>:
      i = i + 1;
      <D.23253>:
      if (i < count) goto <D.23252>; else goto <D.23254>;
      <D.23254>:
      if (total > 0) goto <D.27013>; else goto <D.27014>;
      <D.27013>:
      D.27015 = total_run - total;
      D.27016 = (double) D.27015;
      D.27017 = D.27016 * 1.0e+2;
      D.27018 = (double) total_run;
      D.27019 = D.27017 / D.27018;
      monoeg_g_print ("Overall results: tests: %d, failed: %d, opt combinations: %d (pass: %.2f%%)\n", total_run, total, 27, D.27019);
      goto <D.27020>;
      <D.27014>:
      monoeg_g_print ("Overall results: tests: %d, 100%% pass, opt combinations: %d\n", total_run, 27);
      <D.27020>:
      D.27021 = total;
      return D.27021;
    }
  finally
    {
      run = {CLOBBER};
    }
}


mini_regression (struct MonoImage * image, int verbose, int * total_run)
{
  struct FILE * mini_stats_fd.104;
  char D.27027;
  unsigned int D.27032;
  unsigned int D.27033;
  struct MonoClass * D.27036;
  const char * D.27037;
  int D.27038;
  int D.27043;
  unsigned int D.27044;
  int mono_do_single_method_regression.105;
  int total.106;
  int D.27053;
  struct GSList * mono_single_method_list.107;
  unsigned int D.27055;
  void * mono_current_single_method.108;
  struct MonoMethod * mono_current_single_method.109;
  struct GSList * iftmp.110;
  unsigned int D.27065;
  unsigned int exclude.111;
  unsigned int D.27067;
  unsigned int D.27068;
  guint32 i;
  guint32 opt;
  struct MonoMethod * method;
  char * n;
  struct GTimer * timer;
  struct MonoDomain * domain;
  guint32 exclude;
  int total;

  try
    {
      timer = monoeg_g_timer_new ();
      domain = mono_domain_get ();
      exclude = 0;
      mono_arch_cpu_optimizations (&exclude);
      mini_stats_fd.104 = mini_stats_fd;
      if (mini_stats_fd.104 != 0B) goto <D.27025>; else goto <D.27026>;
      <D.27025>:
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, "$stattitle = \'Mono Benchmark Results (various optimizations)\';\n");
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, "$graph->set_legend(qw(");
      opt = 0;
      goto <D.23218>;
      <D.23217>:
      {
        guint32 opt_flags;

        opt_flags = opt_sets[opt];
        n = opt_descr (opt_flags);
        D.27027 = *n;
        if (D.27027 == 0) goto <D.27028>; else goto <D.27029>;
        <D.27028>:
        n = "none";
        <D.27029>:
        if (opt != 0) goto <D.27030>; else goto <D.27031>;
        <D.27030>:
        mini_stats_fd.104 = mini_stats_fd;
        fprintf (mini_stats_fd.104, " ");
        <D.27031>:
        mini_stats_fd.104 = mini_stats_fd;
        fprintf (mini_stats_fd.104, "%s", n);
      }
      opt = opt + 1;
      <D.23218>:
      if (opt <= 26) goto <D.23217>; else goto <D.23219>;
      <D.23219>:
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, "));\n");
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, "@data = (\n");
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, "[");
      <D.27026>:
      i = 0;
      goto <D.23231>;
      <D.23230>:
      D.27032 = i + 1;
      D.27033 = D.27032 | 100663296;
      method = mono_get_method (image, D.27033, 0B);
      if (method == 0B) goto <D.27034>; else goto <D.27035>;
      <D.27034>:
      // predicted unlikely by continue predictor.
      goto <D.23220>;
      <D.27035>:
      D.27036 = method->klass;
      mono_class_init (D.27036);
      D.27037 = method->name;
      D.27038 = strncmp (D.27037, "test_", 5);
      if (D.27038 == 0) goto <D.27039>; else goto <D.27040>;
      <D.27039>:
      mini_stats_fd.104 = mini_stats_fd;
      if (mini_stats_fd.104 != 0B) goto <D.27041>; else goto <D.27042>;
      <D.27041>:
      D.27037 = method->name;
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, "\"%s\",", D.27037);
      <D.27042>:
      <D.27040>:
      <D.23220>:
      i = i + 1;
      <D.23231>:
      D.27043 = mono_image_get_table_rows (image, 6);
      D.27044 = (unsigned int) D.27043;
      if (D.27044 > i) goto <D.23230>; else goto <D.23232>;
      <D.23232>:
      mini_stats_fd.104 = mini_stats_fd;
      if (mini_stats_fd.104 != 0B) goto <D.27045>; else goto <D.27046>;
      <D.27045>:
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, "],\n");
      <D.27046>:
      total = 0;
      *total_run = 0;
      mono_do_single_method_regression.105 = mono_do_single_method_regression;
      if (mono_do_single_method_regression.105 != 0) goto <D.27048>; else goto <D.27049>;
      <D.27048>:
      {
        struct GSList * iter;

        mini_regression_step (image, verbose, total_run, &total, 0, timer, domain);
        total.106 = total;
        if (total.106 != 0) goto <D.27051>; else goto <D.27052>;
        <D.27051>:
        D.27053 = total;
        return D.27053;
        <D.27052>:
        mono_single_method_list.107 = mono_single_method_list;
        D.27055 = monoeg_g_slist_length (mono_single_method_list.107);
        monoeg_g_print ("Single method regression: %d methods\n", D.27055);
        iter = mono_single_method_list;
        goto <D.23236>;
        <D.23235>:
        {
          char * method_name;

          mono_current_single_method.108 = iter->data;
          mono_current_single_method = mono_current_single_method.108;
          mono_current_single_method.109 = mono_current_single_method;
          method_name = mono_method_full_name (mono_current_single_method.109, 1);
          monoeg_g_print ("Current single method: %s\n", method_name);
          monoeg_g_free (method_name);
          mini_regression_step (image, verbose, total_run, &total, 0, timer, domain);
          total.106 = total;
          if (total.106 != 0) goto <D.27058>; else goto <D.27059>;
          <D.27058>:
          D.27053 = total;
          return D.27053;
          <D.27059>:
        }
        if (iter != 0B) goto <D.27061>; else goto <D.27062>;
        <D.27061>:
        iftmp.110 = iter->next;
        goto <D.27063>;
        <D.27062>:
        iftmp.110 = 0B;
        <D.27063>:
        iter = iftmp.110;
        <D.23236>:
        if (iter != 0B) goto <D.23235>; else goto <D.23237>;
        <D.23237>:
      }
      goto <D.27064>;
      <D.27049>:
      opt = 0;
      goto <D.23239>;
      <D.23238>:
      D.27065 = opt_sets[opt];
      exclude.111 = exclude;
      D.27067 = ~exclude.111;
      D.27068 = D.27065 & D.27067;
      mini_regression_step (image, verbose, total_run, &total, D.27068, timer, domain);
      opt = opt + 1;
      <D.23239>:
      if (opt <= 26) goto <D.23238>; else goto <D.23240>;
      <D.23240>:
      <D.27064>:
      mini_stats_fd.104 = mini_stats_fd;
      if (mini_stats_fd.104 != 0B) goto <D.27069>; else goto <D.27070>;
      <D.27069>:
      mini_stats_fd.104 = mini_stats_fd;
      fprintf (mini_stats_fd.104, ");\n");
      mini_stats_fd.104 = mini_stats_fd;
      fflush (mini_stats_fd.104);
      <D.27070>:
      monoeg_g_timer_destroy (timer);
      D.27053 = total;
      return D.27053;
    }
  finally
    {
      exclude = {CLOBBER};
      total = {CLOBBER};
    }
}


mini_regression_step (struct MonoImage * image, int verbose, int * total_run, int * total, guint32 opt_flags, struct GTimer * timer, struct MonoDomain * domain)
{
  const char * D.27073;
  void * D.27074;
  struct GHashTable * D.27077;
  struct GHashTable * D.27078;
  struct MonoInternalHashTable * D.27079;
  struct FILE * mini_stats_fd.112;
  int D.27083;
  int D.27084;
  unsigned int D.27085;
  const char * D.27088;
  int D.27089;
  const char * D.27092;
  struct MonoDomain * D.27093;
  unsigned int D.27094;
  double D.27095;
  unsigned int D.27096;
  struct MonoDomain * D.27101;
  void * D.27102;
  unsigned char * D.27106;
  struct MonoDomain * D.27107;
  void * D.27108;
  unsigned int D.27111;
  unsigned int code_size.113;
  unsigned int D.27113;
  double D.27119;
  double D.27120;
  int D.27121;
  _Bool D.27124;
  _Bool D.27125;
  _Bool D.27126;
  int D.27129;
  int D.27130;
  double D.27131;
  double D.27132;
  double D.27133;
  double D.27134;
  double D.27136;
  int D.27137;
  int D.27138;
  int D.27139;
  int D.27140;
  int D.27141;
  int result;
  int expected;
  int failed;
  int cfailed;
  int run;
  int code_size;
  int (*TestMethod) (void) func;
  double elapsed;
  double comp_time;
  double start_time;
  char * n;
  int i;

  mono_set_defaults (verbose, opt_flags);
  n = opt_descr (opt_flags);
  D.27073 = mono_image_get_filename (image);
  monoeg_g_print ("Test run: image=%s, opts=%s\n", D.27073, n);
  monoeg_g_free (n);
  code_size = 0;
  run = code_size;
  failed = run;
  cfailed = failed;
  elapsed = 0.0;
  comp_time = elapsed;
  D.27074 = domain->runtime_info;
  if (D.27074 != 0B) goto <D.27075>; else goto <D.27076>;
  <D.27075>:
  D.27074 = domain->runtime_info;
  D.27077 = MEM[(struct MonoJitDomainInfo *)D.27074].jit_trampoline_hash;
  monoeg_g_hash_table_destroy (D.27077);
  D.27074 = domain->runtime_info;
  D.27078 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  MEM[(struct MonoJitDomainInfo *)D.27074].jit_trampoline_hash = D.27078;
  D.27079 = &domain->jit_code_hash;
  mono_internal_hash_table_destroy (D.27079);
  D.27079 = &domain->jit_code_hash;
  mono_jit_code_hash_init (D.27079);
  <D.27076>:
  monoeg_g_timer_start (timer);
  mini_stats_fd.112 = mini_stats_fd;
  if (mini_stats_fd.112 != 0B) goto <D.27081>; else goto <D.27082>;
  <D.27081>:
  mini_stats_fd.112 = mini_stats_fd;
  fprintf (mini_stats_fd.112, "[");
  <D.27082>:
  i = 0;
  goto <D.23201>;
  <D.23200>:
  {
    struct MonoMethod * method;

    D.27083 = i + 1;
    D.27084 = D.27083 | 100663296;
    D.27085 = (unsigned int) D.27084;
    method = mono_get_method (image, D.27085, 0B);
    if (method == 0B) goto <D.27086>; else goto <D.27087>;
    <D.27086>:
    // predicted unlikely by continue predictor.
    goto <D.23189>;
    <D.27087>:
    D.27088 = method->name;
    D.27089 = strncmp (D.27088, "test_", 5);
    if (D.27089 == 0) goto <D.27090>; else goto <D.27091>;
    <D.27090>:
    {
      struct MonoCompile * cfg;

      D.27088 = method->name;
      D.27092 = D.27088 + 5;
      expected = atoi (D.27092);
      run = run + 1;
      start_time = monoeg_g_timer_elapsed (timer, 0B);
      comp_time = comp_time - start_time;
      D.27093 = mono_get_root_domain ();
      D.27094 = mono_get_optimizations_for_method (method, opt_flags);
      cfg = mini_method_compile (method, D.27094, D.27093, 1, 0);
      D.27095 = monoeg_g_timer_elapsed (timer, 0B);
      comp_time = D.27095 + comp_time;
      D.27096 = cfg->exception_type;
      if (D.27096 == 0) goto <D.27097>; else goto <D.27098>;
      <D.27097>:
      if (verbose > 1) goto <D.27099>; else goto <D.27100>;
      <D.27099>:
      D.27088 = method->name;
      monoeg_g_print ("Running \'%s\' ...\n", D.27088);
      <D.27100>:
      D.27101 = mono_get_root_domain ();
      D.27102 = mono_aot_get_method (D.27101, method);
      func = (int (*TestMethod) (void)) D.27102;
      if (func != 0B) goto <D.27103>; else goto <D.27104>;
      <D.27103>:
      goto <D.27105>;
      <D.27104>:
      D.27106 = cfg->native_code;
      func = (int (*TestMethod) (void)) D.27106;
      <D.27105>:
      D.27107 = mono_get_root_domain ();
      D.27108 = mono_create_ftnptr (D.27107, func);
      func = (int (*TestMethod) (void)) D.27108;
      result = func ();
      if (result != expected) goto <D.27109>; else goto <D.27110>;
      <D.27109>:
      failed = failed + 1;
      D.27088 = method->name;
      monoeg_g_print ("Test \'%s\' failed result (got %d, expected %d).\n", D.27088, result, expected);
      <D.27110>:
      D.27111 = cfg->code_len;
      code_size.113 = (unsigned int) code_size;
      D.27113 = D.27111 + code_size.113;
      code_size = (int) D.27113;
      mono_destroy_compile (cfg);
      goto <D.27114>;
      <D.27098>:
      cfailed = cfailed + 1;
      if (verbose != 0) goto <D.27115>; else goto <D.27116>;
      <D.27115>:
      D.27088 = method->name;
      monoeg_g_print ("Test \'%s\' failed compilation.\n", D.27088);
      <D.27116>:
      <D.27114>:
      mini_stats_fd.112 = mini_stats_fd;
      if (mini_stats_fd.112 != 0B) goto <D.27117>; else goto <D.27118>;
      <D.27117>:
      D.27119 = monoeg_g_timer_elapsed (timer, 0B);
      D.27120 = D.27119 - start_time;
      mini_stats_fd.112 = mini_stats_fd;
      fprintf (mini_stats_fd.112, "%f, ", D.27120);
      <D.27118>:
    }
    <D.27091>:
  }
  <D.23189>:
  i = i + 1;
  <D.23201>:
  D.27121 = mono_image_get_table_rows (image, 6);
  if (D.27121 > i) goto <D.23200>; else goto <D.23202>;
  <D.23202>:
  mini_stats_fd.112 = mini_stats_fd;
  if (mini_stats_fd.112 != 0B) goto <D.27122>; else goto <D.27123>;
  <D.27122>:
  mini_stats_fd.112 = mini_stats_fd;
  fprintf (mini_stats_fd.112, "],\n");
  <D.27123>:
  monoeg_g_timer_stop (timer);
  elapsed = monoeg_g_timer_elapsed (timer, 0B);
  D.27124 = failed > 0;
  D.27125 = cfailed > 0;
  D.27126 = D.27124 | D.27125;
  if (D.27126 != 0) goto <D.27127>; else goto <D.27128>;
  <D.27127>:
  D.27129 = run - failed;
  D.27130 = D.27129 - cfailed;
  D.27131 = (double) D.27130;
  D.27132 = D.27131 * 1.0e+2;
  D.27133 = (double) run;
  D.27134 = D.27132 / D.27133;
  monoeg_g_print ("Results: total tests: %d, failed: %d, cfailed: %d (pass: %.2f%%)\n", run, failed, cfailed, D.27134);
  goto <D.27135>;
  <D.27128>:
  monoeg_g_print ("Results: total tests: %d, all pass \n", run);
  <D.27135>:
  D.27136 = elapsed - comp_time;
  monoeg_g_print ("Elapsed time: %f secs (%f, %f), Code size: %d\n\n", elapsed, D.27136, comp_time, code_size);
  D.27137 = *total;
  D.27138 = failed + cfailed;
  D.27139 = D.27137 + D.27138;
  *total = D.27139;
  D.27140 = *total_run;
  D.27141 = D.27140 + run;
  *total_run = D.27141;
}


mini_usage ()
{
  struct _IO_FILE * stdout.114;

  stdout.114 = stdout;
  fprintf (stdout.114, "Usage is: mono [options] program [program-options]\n\nDevelopment:\n    --aot[=<options>]      Compiles the assembly to native code\n    --debug[=<options>]    Enable debugging support, use --help-debug for details\n    --debugger-agent=options Enable the debugger agent\n    --profile[=profiler]   Runs in profiling mode with the specified profiler module\n    --trace[=EXPR]         Enable tracing, use --help-trace for details\n    --jitmap               Output a jit method map to /tmp/perf-PID.map\n    --help-devel           Shows more options available to developers\n\nRuntime:\n    --config FILE          Loads FILE as the Mono config\n    --verbose, -v          Increases the verbosity level\n    --help, -h             Show usage information\n    --version, -V          Show version information\n    --runtime=VERSION      Use the VERSION runtime, instead of autodetecting\n    --optimize=OPT         Turns on or off a specific optimization\n                           Use --list-opt to get a list of optimizations\n    --security[=mode]      Turns on the unsupported security manager (off by default)\n                           mode is one of cas, core-clr, verifiable or validil\n    --attach=OPTIONS       Pass OPTIONS to the attach agent in the runtime.\n                           Currently the only supported option is \'disable\'.\n    --llvm, --nollvm       Controls whenever the runtime uses LLVM to compile code.\n    --gc=[sgen,boehm]      Select SGen or Boehm GC (runs mono or mono-sgen)\n");
}


main_thread_handler (void * user_data)
{
  int mono_compile_aot.115;
  char * * D.27146;
  unsigned int i.116;
  unsigned int D.27148;
  char * * D.27149;
  char * D.27150;
  struct MonoDomain * D.27151;
  struct _IO_FILE * stderr.117;
  int D.23336;
  struct MonoImage * D.27157;
  char * D.27158;
  char * D.27159;
  char * D.27162;
  unsigned int D.27163;
  int D.27166;
  const char * D.27168;
  unsigned int D.27171;
  struct MainThreadArgs * main_args;
  struct MonoAssembly * assembly;

  main_args = user_data;
  mono_compile_aot.115 = mono_compile_aot;
  if (mono_compile_aot.115 != 0) goto <D.27144>; else goto <D.27145>;
  <D.27144>:
  {
    int i;
    int res;

    i = 0;
    goto <D.23338>;
    <D.23337>:
    D.27146 = main_args->argv;
    i.116 = (unsigned int) i;
    D.27148 = i.116 * 4;
    D.27149 = D.27146 + D.27148;
    D.27150 = *D.27149;
    D.27151 = main_args->domain;
    assembly = mono_domain_assembly_open (D.27151, D.27150);
    if (assembly == 0B) goto <D.27152>; else goto <D.27153>;
    <D.27152>:
    D.27146 = main_args->argv;
    i.116 = (unsigned int) i;
    D.27148 = i.116 * 4;
    D.27149 = D.27146 + D.27148;
    D.27150 = *D.27149;
    stderr.117 = stderr;
    fprintf (stderr.117, "Can not open image %s\n", D.27150);
    exit (1);
    <D.27153>:
    {
      MonoImageOpenStatus status;
      struct MonoImage * img;

      try
        {
          D.27146 = main_args->argv;
          i.116 = (unsigned int) i;
          D.27148 = i.116 * 4;
          D.27149 = D.27146 + D.27148;
          D.27150 = *D.27149;
          img = mono_image_open (D.27150, &status);
          if (img != 0B) goto <D.27155>; else goto <D.27156>;
          <D.27155>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.27157 = assembly->image;
            D.27158 = D.27157->name;
            D.27159 = img->name;
            D.23336 = __builtin_strcmp (D.27159, D.27158);
          }
          if (D.23336 != 0) goto <D.27160>; else goto <D.27161>;
          <D.27160>:
          D.27159 = img->name;
          D.27157 = assembly->image;
          D.27158 = D.27157->name;
          stderr.117 = stderr;
          fprintf (stderr.117, "Error: Loaded assembly \'%s\' doesn\'t match original file name \'%s\'. Set MONO_PATH to the assembly\'s location.\n", D.27158, D.27159);
          exit (1);
          <D.27161>:
          <D.27156>:
        }
      finally
        {
          status = {CLOBBER};
        }
    }
    D.27162 = main_args->aot_options;
    D.27163 = main_args->opts;
    res = mono_compile_assembly (assembly, D.27163, D.27162);
    if (res != 0) goto <D.27164>; else goto <D.27165>;
    <D.27164>:
    D.27146 = main_args->argv;
    i.116 = (unsigned int) i;
    D.27148 = i.116 * 4;
    D.27149 = D.27146 + D.27148;
    D.27150 = *D.27149;
    stderr.117 = stderr;
    fprintf (stderr.117, "AOT of image %s failed.\n", D.27150);
    exit (1);
    <D.27165>:
    i = i + 1;
    <D.23338>:
    D.27166 = main_args->argc;
    if (D.27166 > i) goto <D.23337>; else goto <D.23339>;
    <D.23339>:
  }
  goto <D.27167>;
  <D.27145>:
  D.27168 = main_args->file;
  D.27151 = main_args->domain;
  assembly = mono_domain_assembly_open (D.27151, D.27168);
  if (assembly == 0B) goto <D.27169>; else goto <D.27170>;
  <D.27169>:
  D.27168 = main_args->file;
  stderr.117 = stderr;
  fprintf (stderr.117, "Can not open image %s\n", D.27168);
  exit (1);
  <D.27170>:
  D.27163 = main_args->opts;
  D.27171 = D.27163 & 131072;
  if (D.27171 != 0) goto <D.27172>; else goto <D.27173>;
  <D.27172>:
  mono_precompile_assemblies ();
  <D.27173>:
  D.27146 = main_args->argv;
  D.27166 = main_args->argc;
  D.27151 = main_args->domain;
  mono_jit_exec (D.27151, assembly, D.27166, D.27146);
  <D.27167>:
}


compile_all_methods (struct MonoAssembly * ass, int verbose, guint32 opts, guint32 recompilation_times)
{
  struct MonoDomain * D.27174;
  struct CompileAllThreadArgs args;

  try
    {
      args.ass = ass;
      args.verbose = verbose;
      args.opts = opts;
      args.recompilation_times = recompilation_times;
      D.27174 = mono_domain_get ();
      mono_thread_create (D.27174, compile_all_methods_thread_main, &args);
      mono_thread_manage ();
    }
  finally
    {
      args = {CLOBBER};
    }
}


compile_all_methods_thread_main (struct CompileAllThreadArgs * args)
{
  unsigned int D.27175;
  guint32 i;

  i = 0;
  goto <D.23293>;
  <D.23292>:
  compile_all_methods_thread_main_inner (args);
  i = i + 1;
  <D.23293>:
  D.27175 = args->recompilation_times;
  if (D.27175 > i) goto <D.23292>; else goto <D.23294>;
  <D.23294>:
}


compile_all_methods_thread_main_inner (struct CompileAllThreadArgs * args)
{
  int D.27176;
  int D.27177;
  int D.27178;
  short unsigned int D.27185;
  int D.27186;
  int D.27187;
  short unsigned int D.27189;
  int D.27190;
  int D.27191;
  int D.27193;
  int D.27195;
  struct MonoClass * D.27196;
  struct MonoGenericContainer * D.27197;
  unsigned char D.27202;
  unsigned char D.27203;
  struct MonoDomain * D.27208;
  unsigned int D.27209;
  unsigned int D.27210;
  unsigned int D.27211;
  char * D.27214;
  struct MonoMethod * D.27215;
  char * D.27216;
  int D.27217;
  struct MonoAssembly * ass;
  int verbose;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct MonoCompile * cfg;
  int i;
  int count;
  int fail_count;

  ass = args->ass;
  verbose = args->verbose;
  image = mono_assembly_get_image (ass);
  count = 0;
  fail_count = 0;
  i = 0;
  goto <D.23286>;
  <D.23285>:
  {
    guint32 token;
    struct MonoMethodSignature * sig;

    D.27176 = i + 1;
    D.27177 = D.27176 | 100663296;
    token = (guint32) D.27177;
    D.27178 = mono_metadata_has_generic_params (image, token);
    if (D.27178 != 0) goto <D.27179>; else goto <D.27180>;
    <D.27179>:
    // predicted unlikely by continue predictor.
    goto <D.23282>;
    <D.27180>:
    method = mono_get_method (image, token, 0B);
    if (method == 0B) goto <D.27181>; else goto <D.27182>;
    <D.27181>:
    // predicted unlikely by continue predictor.
    goto <D.23282>;
    <D.27182>:
    D.27185 = method->iflags;
    D.27186 = (int) D.27185;
    D.27187 = D.27186 & 4096;
    if (D.27187 != 0) goto <D.27183>; else goto <D.27188>;
    <D.27188>:
    D.27189 = method->flags;
    D.27190 = (int) D.27189;
    D.27191 = D.27190 & 8192;
    if (D.27191 != 0) goto <D.27183>; else goto <D.27192>;
    <D.27192>:
    D.27185 = method->iflags;
    D.27186 = (int) D.27185;
    D.27193 = D.27186 & 3;
    if (D.27193 != 0) goto <D.27183>; else goto <D.27194>;
    <D.27194>:
    D.27189 = method->flags;
    D.27190 = (int) D.27189;
    D.27195 = D.27190 & 1024;
    if (D.27195 != 0) goto <D.27183>; else goto <D.27184>;
    <D.27183>:
    // predicted unlikely by continue predictor.
    goto <D.23282>;
    <D.27184>:
    D.27196 = method->klass;
    D.27197 = D.27196->generic_container;
    if (D.27197 != 0B) goto <D.27198>; else goto <D.27199>;
    <D.27198>:
    // predicted unlikely by continue predictor.
    goto <D.23282>;
    <D.27199>:
    sig = mono_method_signature (method);
    if (sig == 0B) goto <D.27200>; else goto <D.27201>;
    <D.27200>:
    {
      char * desc;

      desc = mono_method_full_name (method, 1);
      monoeg_g_print ("Could not retrieve method signature for %s\n", desc);
      monoeg_g_free (desc);
      fail_count = fail_count + 1;
      // predicted unlikely by continue predictor.
      goto <D.23282>;
    }
    <D.27201>:
    D.27202 = BIT_FIELD_REF <*sig, 8, 88>;
    D.27203 = D.27202 & 4;
    if (D.27203 != 0) goto <D.27204>; else goto <D.27205>;
    <D.27204>:
    // predicted unlikely by continue predictor.
    goto <D.23282>;
    <D.27205>:
    count = count + 1;
    if (verbose != 0) goto <D.27206>; else goto <D.27207>;
    <D.27206>:
    {
      char * desc;

      desc = mono_method_full_name (method, 1);
      monoeg_g_print ("Compiling %d %s\n", count, desc);
      monoeg_g_free (desc);
    }
    <D.27207>:
    D.27208 = mono_get_root_domain ();
    D.27209 = args->opts;
    D.27210 = mono_get_optimizations_for_method (method, D.27209);
    cfg = mini_method_compile (method, D.27210, D.27208, 0, 0);
    D.27211 = cfg->exception_type;
    if (D.27211 != 0) goto <D.27212>; else goto <D.27213>;
    <D.27212>:
    D.27214 = cfg->exception_message;
    D.27215 = cfg->method;
    D.27216 = mono_method_full_name (D.27215, 1);
    printf ("Compilation of %s failed with exception \'%s\':\n", D.27216, D.27214);
    fail_count = fail_count + 1;
    <D.27213>:
    mono_destroy_compile (cfg);
  }
  <D.23282>:
  i = i + 1;
  <D.23286>:
  D.27217 = mono_image_get_table_rows (image, 6);
  if (D.27217 > i) goto <D.23285>; else goto <D.23287>;
  <D.23287>:
  if (fail_count != 0) goto <D.27218>; else goto <D.27219>;
  <D.27218>:
  exit (1);
  <D.27219>:
}


printf (const char * restrict __fmt)
{
  int D.27220;

  D.27220 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.27220;
}


opt_descr (guint32 flags)
{
  int D.27222;
  unsigned int D.27223;
  unsigned int D.27224;
  short int D.27229;
  sizetype D.27230;
  const gchar * D.27231;
  unsigned int i.118;
  char * D.27233;
  struct GString * str;
  int i;
  int need_comma;

  str = monoeg_g_string_new ("");
  need_comma = 0;
  i = 0;
  goto <D.23162>;
  <D.23161>:
  D.27222 = 1 << i;
  D.27223 = (unsigned int) D.27222;
  D.27224 = D.27223 & flags;
  if (D.27224 != 0) goto <D.27225>; else goto <D.27226>;
  <D.27225>:
  if (need_comma != 0) goto <D.27227>; else goto <D.27228>;
  <D.27227>:
  monoeg_g_string_append_c (str, 44);
  <D.27228>:
  D.27229 = opt_names[i];
  D.27230 = (sizetype) D.27229;
  D.27231 = &opstr + D.27230;
  monoeg_g_string_append (str, D.27231);
  need_comma = 1;
  <D.27226>:
  i = i + 1;
  <D.23162>:
  i.118 = (unsigned int) i;
  if (i.118 <= 28) goto <D.23161>; else goto <D.23163>;
  <D.23163>:
  D.27233 = monoeg_g_string_free (str, 0);
  return D.27233;
}


mono_jit_init (const char * file)
{
  struct MonoDomain * D.27235;

  D.27235 = mini_init (file, 0B);
  return D.27235;
}


mono_jit_init_version (const char * domain_name, const char * runtime_version)
{
  struct MonoDomain * D.27237;

  D.27237 = mini_init (domain_name, runtime_version);
  return D.27237;
}


mono_jit_cleanup (struct MonoDomain * domain)
{
  mini_cleanup (domain);
}


mono_jit_set_aot_only (gboolean val)
{
  mono_aot_only = val;
}


mono_jit_set_trace_options (const char * options)
{
  mono_bool D.27241;
  struct MonoTraceSpec * trace_opt;

  trace_opt = mono_trace_parse_options (options);
  if (trace_opt == 0B) goto <D.27239>; else goto <D.27240>;
  <D.27239>:
  D.27241 = 0;
  return D.27241;
  <D.27240>:
  mono_jit_trace_calls = trace_opt;
  D.27241 = 1;
  return D.27241;
}


mono_set_signal_chaining (gboolean chain_signals)
{
  mono_do_signal_chaining = chain_signals;
}


