mono_security_core_clr_set_options (MonoSecurityCoreCLROptions options)
{
  security_core_clr_options = options;
}


mono_security_core_clr_get_options ()
{
  MonoSecurityCoreCLROptions D.18426;

  D.18426 = security_core_clr_options;
  return D.18426;
}


mono_security_core_clr_determine_platform_image (struct MonoImage * image)
{
  gboolean D.18428;
  mono_bool (*<Tc01>) (const char *) platform_callback.0;
  char * D.18430;

  platform_callback.0 = platform_callback;
  D.18430 = image->name;
  D.18428 = platform_callback.0 (D.18430);
  return D.18428;
}


default_platform_check (const char * image_name)
{
  struct MonoImage * D.18432;
  gboolean D.18435;
  int D.18015;
  char * D.18436;
  _Bool D.18437;
  long unsigned int D.18438;
  long unsigned int D.18439;
  int iftmp.1;
  int D.18027;
  int iftmp.2;
  int D.18023;
  sizetype D.18447;
  sizetype D.18448;
  sizetype D.18449;
  const char[13] * D.18450;
  unsigned char D.18451;
  int D.18452;
  unsigned char D.18453;
  int D.18454;
  const unsigned char * D.18459;
  unsigned char D.18460;
  int D.18461;
  const unsigned char * D.18462;
  unsigned char D.18463;
  int D.18464;
  const unsigned char * D.18469;
  unsigned char D.18470;
  int D.18471;
  const unsigned char * D.18472;
  unsigned char D.18473;
  int D.18474;
  const unsigned char * D.18479;
  unsigned char D.18480;
  int D.18481;
  const unsigned char * D.18482;
  unsigned char D.18483;
  int D.18484;
  const char * D.18486;

  D.18432 = mono_defaults.corlib;
  if (D.18432 != 0B) goto <D.18433>; else goto <D.18434>;
  <D.18433>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.18432 = mono_defaults.corlib;
    D.18436 = D.18432->name;
    D.18015 = __builtin_strcmp (D.18436, image_name);
  }
  D.18437 = D.18015 == 0;
  D.18435 = (gboolean) D.18437;
  return D.18435;
  <D.18434>:
  {
    const char * corlib;
    int ilen;
    int clen;

    corlib = "mscorlib.dll";
    D.18438 = strlen (image_name);
    ilen = (int) D.18438;
    D.18439 = strlen (corlib);
    clen = (int) D.18439;
    if (ilen >= clen) goto <D.18443>; else goto <D.18441>;
    <D.18443>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 12;
      if (__s1_len <= 3) goto <D.18445>; else goto <D.18446>;
      <D.18445>:
      {
        const unsigned char * __s2;
        int __result;

        D.18447 = (sizetype) ilen;
        D.18448 = (sizetype) clen;
        D.18449 = D.18447 - D.18448;
        __s2 = image_name + D.18449;
        D.18450 = "mscorlib.dll";
        D.18451 = MEM[(const unsigned char *)D.18450];
        D.18452 = (int) D.18451;
        D.18453 = *__s2;
        D.18454 = (int) D.18453;
        __result = D.18452 - D.18454;
        {
          if (__s1_len != 0) goto <D.18455>; else goto <D.18456>;
          <D.18455>:
          if (__result == 0) goto <D.18457>; else goto <D.18458>;
          <D.18457>:
          D.18459 = &MEM[(void *)"mscorlib.dll" + 1B];
          D.18460 = *D.18459;
          D.18461 = (int) D.18460;
          D.18462 = __s2 + 1;
          D.18463 = *D.18462;
          D.18464 = (int) D.18463;
          __result = D.18461 - D.18464;
          if (__s1_len > 1) goto <D.18465>; else goto <D.18466>;
          <D.18465>:
          if (__result == 0) goto <D.18467>; else goto <D.18468>;
          <D.18467>:
          D.18469 = &MEM[(void *)"mscorlib.dll" + 2B];
          D.18470 = *D.18469;
          D.18471 = (int) D.18470;
          D.18472 = __s2 + 2;
          D.18473 = *D.18472;
          D.18474 = (int) D.18473;
          __result = D.18471 - D.18474;
          if (__s1_len > 2) goto <D.18475>; else goto <D.18476>;
          <D.18475>:
          if (__result == 0) goto <D.18477>; else goto <D.18478>;
          <D.18477>:
          D.18479 = &MEM[(void *)"mscorlib.dll" + 3B];
          D.18480 = *D.18479;
          D.18481 = (int) D.18480;
          D.18482 = __s2 + 3;
          D.18483 = *D.18482;
          D.18484 = (int) D.18483;
          __result = D.18481 - D.18484;
          <D.18478>:
          <D.18476>:
          <D.18468>:
          <D.18466>:
          <D.18458>:
          <D.18456>:
        }
        D.18023 = __result;
      }
      iftmp.2 = D.18023;
      goto <D.18485>;
      <D.18446>:
      D.18447 = (sizetype) ilen;
      D.18448 = (sizetype) clen;
      D.18449 = D.18447 - D.18448;
      D.18486 = image_name + D.18449;
      iftmp.2 = __builtin_strcmp ("mscorlib.dll", D.18486);
      <D.18485>:
      D.18027 = iftmp.2;
    }
    if (D.18027 == 0) goto <D.18487>; else goto <D.18441>;
    <D.18487>:
    iftmp.1 = 1;
    goto <D.18442>;
    <D.18441>:
    iftmp.1 = 0;
    <D.18442>:
    D.18435 = iftmp.1;
    return D.18435;
  }
}


mono_security_set_core_clr_platform_callback (mono_bool (*MonoCoreClrPlatformCB) (const char *) callback)
{
  platform_callback = callback;
}


mono_security_core_clr_is_platform_image (struct MonoImage * image)
{
  gboolean D.18489;
  <unnamed-unsigned:1> D.18490;

  D.18490 = image->core_clr_platform_code;
  D.18489 = (gboolean) D.18490;
  return D.18489;
}


mono_security_core_clr_check_inheritance (struct MonoClass * class)
{
  short unsigned int D.18499;
  int D.18500;
  int D.18501;
  struct MonoMethod * D.18504;
  MonoSecurityCoreCLRLevel class_level;
  MonoSecurityCoreCLRLevel parent_level;
  struct MonoClass * parent;

  parent = class->parent;
  if (parent == 0B) goto <D.18492>; else goto <D.18493>;
  <D.18492>:
  return;
  <D.18493>:
  class_level = mono_security_core_clr_class_level (class);
  parent_level = mono_security_core_clr_class_level (parent);
  if (class_level < parent_level) goto <D.18494>; else goto <D.18495>;
  <D.18494>:
  set_type_load_exception_type ("Inheritance failure for type %s. Parent class %s is more restricted.", class);
  goto <D.18496>;
  <D.18495>:
  {
    struct MonoMethod * parent_ctor;

    parent_ctor = get_default_ctor (parent);
    if (parent_ctor != 0B) goto <D.18497>; else goto <D.18498>;
    <D.18497>:
    D.18499 = parent_ctor->flags;
    D.18500 = (int) D.18499;
    D.18501 = D.18500 & 6;
    if (D.18501 != 0) goto <D.18502>; else goto <D.18503>;
    <D.18502>:
    D.18504 = get_default_ctor (class);
    class_level = mono_security_core_clr_method_level (D.18504, 0);
    parent_level = mono_security_core_clr_method_level (parent_ctor, 0);
    if (class_level < parent_level) goto <D.18505>; else goto <D.18506>;
    <D.18505>:
    set_type_load_exception_type ("Inheritance failure for type %s. Default constructor security mismatch with %s.", class);
    <D.18506>:
    <D.18503>:
    <D.18498>:
  }
  <D.18496>:
}


get_default_ctor (struct MonoClass * klass)
{
  struct MonoMethod * * D.18508;
  struct MonoMethod * D.18511;
  long unsigned int D.18512;
  long unsigned int D.18513;
  struct MonoMethod * * D.18514;
  short unsigned int D.18517;
  int D.18518;
  int D.18519;
  const char * D.18524;
  char D.18525;
  int D.18079;
  int iftmp.3;
  int D.18075;
  const char[6] * D.18530;
  unsigned char D.18531;
  int D.18532;
  unsigned char D.18533;
  int D.18534;
  const unsigned char * D.18539;
  unsigned char D.18540;
  int D.18541;
  const unsigned char * D.18542;
  unsigned char D.18543;
  int D.18544;
  const unsigned char * D.18549;
  unsigned char D.18550;
  int D.18551;
  const unsigned char * D.18552;
  unsigned char D.18553;
  int D.18554;
  const unsigned char * D.18559;
  unsigned char D.18560;
  int D.18561;
  const unsigned char * D.18562;
  unsigned char D.18563;
  int D.18564;
  short unsigned int D.18568;
  unsigned int i.4;
  unsigned int D.18572;
  int i;

  mono_class_setup_methods (klass);
  D.18508 = klass->methods;
  if (D.18508 == 0B) goto <D.18509>; else goto <D.18510>;
  <D.18509>:
  D.18511 = 0B;
  return D.18511;
  <D.18510>:
  i = 0;
  goto <D.18081>;
  <D.18080>:
  {
    struct MonoMethodSignature * sig;
    struct MonoMethod * method;

    D.18508 = klass->methods;
    D.18512 = (long unsigned int) i;
    D.18513 = D.18512 * 8;
    D.18514 = D.18508 + D.18513;
    method = *D.18514;
    if (method == 0B) goto <D.18515>; else goto <D.18516>;
    <D.18515>:
    // predicted unlikely by continue predictor.
    goto <D.18070>;
    <D.18516>:
    D.18517 = method->flags;
    D.18518 = (int) D.18517;
    D.18519 = D.18518 & 2048;
    if (D.18519 == 0) goto <D.18520>; else goto <D.18521>;
    <D.18520>:
    // predicted unlikely by continue predictor.
    goto <D.18070>;
    <D.18521>:
    D.18524 = method->name;
    D.18525 = *D.18524;
    if (D.18525 != 46) goto <D.18522>; else goto <D.18526>;
    <D.18526>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 5;
      if (__s1_len <= 3) goto <D.18528>; else goto <D.18529>;
      <D.18528>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = method->name;
        D.18530 = ".ctor";
        D.18531 = MEM[(const unsigned char *)D.18530];
        D.18532 = (int) D.18531;
        D.18533 = *__s2;
        D.18534 = (int) D.18533;
        __result = D.18532 - D.18534;
        {
          if (__s1_len != 0) goto <D.18535>; else goto <D.18536>;
          <D.18535>:
          if (__result == 0) goto <D.18537>; else goto <D.18538>;
          <D.18537>:
          D.18539 = &MEM[(void *)".ctor" + 1B];
          D.18540 = *D.18539;
          D.18541 = (int) D.18540;
          D.18542 = __s2 + 1;
          D.18543 = *D.18542;
          D.18544 = (int) D.18543;
          __result = D.18541 - D.18544;
          if (__s1_len > 1) goto <D.18545>; else goto <D.18546>;
          <D.18545>:
          if (__result == 0) goto <D.18547>; else goto <D.18548>;
          <D.18547>:
          D.18549 = &MEM[(void *)".ctor" + 2B];
          D.18550 = *D.18549;
          D.18551 = (int) D.18550;
          D.18552 = __s2 + 2;
          D.18553 = *D.18552;
          D.18554 = (int) D.18553;
          __result = D.18551 - D.18554;
          if (__s1_len > 2) goto <D.18555>; else goto <D.18556>;
          <D.18555>:
          if (__result == 0) goto <D.18557>; else goto <D.18558>;
          <D.18557>:
          D.18559 = &MEM[(void *)".ctor" + 3B];
          D.18560 = *D.18559;
          D.18561 = (int) D.18560;
          D.18562 = __s2 + 3;
          D.18563 = *D.18562;
          D.18564 = (int) D.18563;
          __result = D.18561 - D.18564;
          <D.18558>:
          <D.18556>:
          <D.18548>:
          <D.18546>:
          <D.18538>:
          <D.18536>:
        }
        D.18075 = __result;
      }
      iftmp.3 = D.18075;
      goto <D.18565>;
      <D.18529>:
      D.18524 = method->name;
      iftmp.3 = __builtin_strcmp (".ctor", D.18524);
      <D.18565>:
      D.18079 = iftmp.3;
    }
    if (D.18079 != 0) goto <D.18522>; else goto <D.18523>;
    <D.18522>:
    // predicted unlikely by continue predictor.
    goto <D.18070>;
    <D.18523>:
    sig = mono_method_signature (method);
    if (sig != 0B) goto <D.18566>; else goto <D.18567>;
    <D.18566>:
    D.18568 = sig->param_count;
    if (D.18568 == 0) goto <D.18569>; else goto <D.18570>;
    <D.18569>:
    D.18511 = method;
    return D.18511;
    <D.18570>:
    <D.18567>:
  }
  <D.18070>:
  i = i + 1;
  <D.18081>:
  i.4 = (unsigned int) i;
  D.18572 = klass->method.count;
  if (i.4 < D.18572) goto <D.18080>; else goto <D.18082>;
  <D.18082>:
  D.18511 = 0B;
  return D.18511;
}


set_type_load_exception_type (const char * format, struct MonoClass * class)
{
  struct MonoClass * D.18574;
  char * type_name;
  char * parent_name;
  char * message;

  type_name = mono_type_get_full_name (class);
  D.18574 = class->parent;
  parent_name = mono_type_get_full_name (D.18574);
  message = monoeg_g_strdup_printf (format, type_name, parent_name);
  monoeg_g_free (parent_name);
  monoeg_g_free (type_name);
  mono_trace (16, 64, message);
  mono_class_set_failure (class, 7, message);
}


mono_security_core_clr_check_override (struct MonoClass * class, struct MonoMethod * override, struct MonoMethod * base)
{
  MonoSecurityCoreCLRLevel base_level;
  MonoSecurityCoreCLRLevel override_level;

  base_level = mono_security_core_clr_method_level (base, 0);
  override_level = mono_security_core_clr_method_level (override, 0);
  if (base_level == 2) goto <D.18575>; else goto <D.18576>;
  <D.18575>:
  if (override_level != 2) goto <D.18577>; else goto <D.18578>;
  <D.18577>:
  set_type_load_exception_methods ("Override failure for %s over %s. Override MUST be [SecurityCritical].", override, base);
  <D.18578>:
  goto <D.18579>;
  <D.18576>:
  if (override_level == 2) goto <D.18580>; else goto <D.18581>;
  <D.18580>:
  set_type_load_exception_methods ("Override failure for %s over %s. Override must NOT be [SecurityCritical].", override, base);
  <D.18581>:
  <D.18579>:
}


set_type_load_exception_methods (const char * format, struct MonoMethod * override, struct MonoMethod * base)
{
  struct MonoClass * D.18582;
  char * method_name;
  char * base_name;
  char * message;

  method_name = get_method_full_name (override);
  base_name = get_method_full_name (base);
  message = monoeg_g_strdup_printf (format, method_name, base_name);
  monoeg_g_free (base_name);
  monoeg_g_free (method_name);
  mono_trace (16, 64, message);
  D.18582 = override->klass;
  mono_class_set_failure (D.18582, 7, message);
}


get_method_full_name (struct MonoMethod * method)
{
  char * D.18583;
  char * iftmp.5;

  if (method != 0B) goto <D.18585>; else goto <D.18586>;
  <D.18585>:
  iftmp.5 = mono_method_full_name (method, 1);
  goto <D.18587>;
  <D.18586>:
  iftmp.5 = monoeg_strdup ("\'no caller found\'");
  <D.18587>:
  D.18583 = iftmp.5;
  return D.18583;
}


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

  if (str != 0B) goto <D.18589>; else goto <D.18590>;
  <D.18589>:
  D.18591 = __strdup (str);
  return D.18591;
  <D.18590>:
  D.18591 = 0B;
  return D.18591;
}


mono_security_core_clr_require_elevated_permissions ()
{
  struct MonoMethod * D.18595;
  int D.18597;
  gboolean D.18598;
  <unnamed type> D.18599;
  _Bool D.18600;
  struct ElevatedTrustCookie cookie;

  try
    {
      cookie.depth = 0;
      cookie.caller = 0B;
      mono_stack_walk_no_il (get_caller_of_elevated_trust_code, &cookie);
      D.18595 = cookie.caller;
      if (D.18595 == 0B) goto <D.18593>; else goto <D.18596>;
      <D.18596>:
      D.18597 = cookie.depth;
      if (D.18597 <= 2) goto <D.18593>; else goto <D.18594>;
      <D.18593>:
      D.18598 = 1;
      return D.18598;
      <D.18594>:
      D.18595 = cookie.caller;
      D.18599 = mono_security_core_clr_method_level (D.18595, 1);
      D.18600 = D.18599 == 0;
      D.18598 = (gboolean) D.18600;
      return D.18598;
    }
  finally
    {
      cookie = {CLOBBER};
    }
}


get_caller_of_elevated_trust_code (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  long unsigned int D.18606;
  long unsigned int D.18607;
  gboolean D.18608;
  struct MonoClass * D.18609;
  struct MonoImage * D.18610;
  int D.18611;
  int D.18614;
  int D.18222;
  int iftmp.6;
  int D.18221;
  const char[16] * D.18618;
  unsigned char D.18619;
  int D.18620;
  unsigned char D.18621;
  int D.18622;
  const unsigned char * D.18627;
  unsigned char D.18628;
  int D.18629;
  const unsigned char * D.18630;
  unsigned char D.18631;
  int D.18632;
  const unsigned char * D.18637;
  unsigned char D.18638;
  int D.18639;
  const unsigned char * D.18640;
  unsigned char D.18641;
  int D.18642;
  const unsigned char * D.18647;
  unsigned char D.18648;
  int D.18649;
  const unsigned char * D.18650;
  unsigned char D.18651;
  int D.18652;
  const char * D.18654;
  int D.18231;
  int iftmp.7;
  int D.18230;
  const char[16] * D.18660;
  unsigned char D.18661;
  int D.18662;
  unsigned char D.18663;
  int D.18664;
  const unsigned char * D.18669;
  unsigned char D.18670;
  int D.18671;
  const unsigned char * D.18672;
  unsigned char D.18673;
  int D.18674;
  const unsigned char * D.18679;
  unsigned char D.18680;
  int D.18681;
  const unsigned char * D.18682;
  unsigned char D.18683;
  int D.18684;
  const unsigned char * D.18689;
  unsigned char D.18690;
  int D.18691;
  const unsigned char * D.18692;
  unsigned char D.18693;
  int D.18694;
  const char * D.18696;
  int D.18240;
  int iftmp.8;
  int D.18239;
  const char[26] * D.18702;
  unsigned char D.18703;
  int D.18704;
  unsigned char D.18705;
  int D.18706;
  const unsigned char * D.18711;
  unsigned char D.18712;
  int D.18713;
  const unsigned char * D.18714;
  unsigned char D.18715;
  int D.18716;
  const unsigned char * D.18721;
  unsigned char D.18722;
  int D.18723;
  const unsigned char * D.18724;
  unsigned char D.18725;
  int D.18726;
  const unsigned char * D.18731;
  unsigned char D.18732;
  int D.18733;
  const unsigned char * D.18734;
  unsigned char D.18735;
  int D.18736;
  const char * D.18738;
  int D.18249;
  int iftmp.9;
  int D.18248;
  const char[25] * D.18744;
  unsigned char D.18745;
  int D.18746;
  unsigned char D.18747;
  int D.18748;
  const unsigned char * D.18753;
  unsigned char D.18754;
  int D.18755;
  const unsigned char * D.18756;
  unsigned char D.18757;
  int D.18758;
  const unsigned char * D.18763;
  unsigned char D.18764;
  int D.18765;
  const unsigned char * D.18766;
  unsigned char D.18767;
  int D.18768;
  const unsigned char * D.18773;
  unsigned char D.18774;
  int D.18775;
  const unsigned char * D.18776;
  unsigned char D.18777;
  int D.18778;
  int D.18782;
  <unnamed type> D.18783;
  struct ElevatedTrustCookie * cookie;

  cookie = data;
  if (managed == 0) goto <D.18603>; else goto <D.18605>;
  <D.18605>:
  D.18606 = BIT_FIELD_REF <*m, 64, 256>;
  D.18607 = D.18606 & 124;
  if (D.18607 != 0) goto <D.18603>; else goto <D.18604>;
  <D.18603>:
  D.18608 = 0;
  return D.18608;
  <D.18604>:
  D.18609 = m->klass;
  D.18610 = D.18609->image;
  D.18611 = mono_security_core_clr_is_platform_image (D.18610);
  if (D.18611 == 0) goto <D.18612>; else goto <D.18613>;
  <D.18612>:
  cookie->caller = m;
  D.18608 = 1;
  return D.18608;
  <D.18613>:
  D.18614 = cookie->depth;
  switch (D.18614) <default: <D.18252>, case 0: <D.18213>, case 1: <D.18251>>
  <D.18213>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.18609 = m->klass;
      __s2 = D.18609->name_space;
      D.18618 = "System.Security";
      D.18619 = MEM[(const unsigned char *)D.18618];
      D.18620 = (int) D.18619;
      D.18621 = *__s2;
      D.18622 = (int) D.18621;
      __result = D.18620 - D.18622;
      {
        if (__s2_len != 0) goto <D.18623>; else goto <D.18624>;
        <D.18623>:
        if (__result == 0) goto <D.18625>; else goto <D.18626>;
        <D.18625>:
        D.18627 = &MEM[(void *)"System.Security" + 1B];
        D.18628 = *D.18627;
        D.18629 = (int) D.18628;
        D.18630 = __s2 + 1;
        D.18631 = *D.18630;
        D.18632 = (int) D.18631;
        __result = D.18629 - D.18632;
        if (__s2_len > 1) goto <D.18633>; else goto <D.18634>;
        <D.18633>:
        if (__result == 0) goto <D.18635>; else goto <D.18636>;
        <D.18635>:
        D.18637 = &MEM[(void *)"System.Security" + 2B];
        D.18638 = *D.18637;
        D.18639 = (int) D.18638;
        D.18640 = __s2 + 2;
        D.18641 = *D.18640;
        D.18642 = (int) D.18641;
        __result = D.18639 - D.18642;
        if (__s2_len > 2) goto <D.18643>; else goto <D.18644>;
        <D.18643>:
        if (__result == 0) goto <D.18645>; else goto <D.18646>;
        <D.18645>:
        D.18647 = &MEM[(void *)"System.Security" + 3B];
        D.18648 = *D.18647;
        D.18649 = (int) D.18648;
        D.18650 = __s2 + 3;
        D.18651 = *D.18650;
        D.18652 = (int) D.18651;
        __result = D.18649 - D.18652;
        <D.18646>:
        <D.18644>:
        <D.18636>:
        <D.18634>:
        <D.18626>:
        <D.18624>:
      }
      D.18221 = __result;
    }
    iftmp.6 = -D.18221;
    goto <D.18653>;
    <D.18617>:
    D.18609 = m->klass;
    D.18654 = D.18609->name_space;
    iftmp.6 = __builtin_strcmp (D.18654, "System.Security");
    <D.18653>:
    D.18222 = iftmp.6;
  }
  if (D.18222 != 0) goto <D.18655>; else goto <D.18656>;
  <D.18655>:
  D.18608 = 0;
  return D.18608;
  <D.18656>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.18609 = m->klass;
      __s2 = D.18609->name;
      D.18660 = "SecurityManager";
      D.18661 = MEM[(const unsigned char *)D.18660];
      D.18662 = (int) D.18661;
      D.18663 = *__s2;
      D.18664 = (int) D.18663;
      __result = D.18662 - D.18664;
      {
        if (__s2_len != 0) goto <D.18665>; else goto <D.18666>;
        <D.18665>:
        if (__result == 0) goto <D.18667>; else goto <D.18668>;
        <D.18667>:
        D.18669 = &MEM[(void *)"SecurityManager" + 1B];
        D.18670 = *D.18669;
        D.18671 = (int) D.18670;
        D.18672 = __s2 + 1;
        D.18673 = *D.18672;
        D.18674 = (int) D.18673;
        __result = D.18671 - D.18674;
        if (__s2_len > 1) goto <D.18675>; else goto <D.18676>;
        <D.18675>:
        if (__result == 0) goto <D.18677>; else goto <D.18678>;
        <D.18677>:
        D.18679 = &MEM[(void *)"SecurityManager" + 2B];
        D.18680 = *D.18679;
        D.18681 = (int) D.18680;
        D.18682 = __s2 + 2;
        D.18683 = *D.18682;
        D.18684 = (int) D.18683;
        __result = D.18681 - D.18684;
        if (__s2_len > 2) goto <D.18685>; else goto <D.18686>;
        <D.18685>:
        if (__result == 0) goto <D.18687>; else goto <D.18688>;
        <D.18687>:
        D.18689 = &MEM[(void *)"SecurityManager" + 3B];
        D.18690 = *D.18689;
        D.18691 = (int) D.18690;
        D.18692 = __s2 + 3;
        D.18693 = *D.18692;
        D.18694 = (int) D.18693;
        __result = D.18691 - D.18694;
        <D.18688>:
        <D.18686>:
        <D.18678>:
        <D.18676>:
        <D.18668>:
        <D.18666>:
      }
      D.18230 = __result;
    }
    iftmp.7 = -D.18230;
    goto <D.18695>;
    <D.18659>:
    D.18609 = m->klass;
    D.18696 = D.18609->name;
    iftmp.7 = __builtin_strcmp (D.18696, "SecurityManager");
    <D.18695>:
    D.18231 = iftmp.7;
  }
  if (D.18231 != 0) goto <D.18697>; else goto <D.18698>;
  <D.18697>:
  D.18608 = 0;
  return D.18608;
  <D.18698>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.18702 = "EnsureElevatedPermissions";
      D.18703 = MEM[(const unsigned char *)D.18702];
      D.18704 = (int) D.18703;
      D.18705 = *__s2;
      D.18706 = (int) D.18705;
      __result = D.18704 - D.18706;
      {
        if (__s2_len != 0) goto <D.18707>; else goto <D.18708>;
        <D.18707>:
        if (__result == 0) goto <D.18709>; else goto <D.18710>;
        <D.18709>:
        D.18711 = &MEM[(void *)"EnsureElevatedPermissions" + 1B];
        D.18712 = *D.18711;
        D.18713 = (int) D.18712;
        D.18714 = __s2 + 1;
        D.18715 = *D.18714;
        D.18716 = (int) D.18715;
        __result = D.18713 - D.18716;
        if (__s2_len > 1) goto <D.18717>; else goto <D.18718>;
        <D.18717>:
        if (__result == 0) goto <D.18719>; else goto <D.18720>;
        <D.18719>:
        D.18721 = &MEM[(void *)"EnsureElevatedPermissions" + 2B];
        D.18722 = *D.18721;
        D.18723 = (int) D.18722;
        D.18724 = __s2 + 2;
        D.18725 = *D.18724;
        D.18726 = (int) D.18725;
        __result = D.18723 - D.18726;
        if (__s2_len > 2) goto <D.18727>; else goto <D.18728>;
        <D.18727>:
        if (__result == 0) goto <D.18729>; else goto <D.18730>;
        <D.18729>:
        D.18731 = &MEM[(void *)"EnsureElevatedPermissions" + 3B];
        D.18732 = *D.18731;
        D.18733 = (int) D.18732;
        D.18734 = __s2 + 3;
        D.18735 = *D.18734;
        D.18736 = (int) D.18735;
        __result = D.18733 - D.18736;
        <D.18730>:
        <D.18728>:
        <D.18720>:
        <D.18718>:
        <D.18710>:
        <D.18708>:
      }
      D.18239 = __result;
    }
    iftmp.8 = -D.18239;
    goto <D.18737>;
    <D.18701>:
    D.18738 = m->name;
    iftmp.8 = __builtin_strcmp (D.18738, "EnsureElevatedPermissions");
    <D.18737>:
    D.18240 = iftmp.8;
  }
  if (D.18240 != 0) goto <D.18739>; else goto <D.18740>;
  <D.18739>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.18744 = "CheckElevatedPermissions";
      D.18745 = MEM[(const unsigned char *)D.18744];
      D.18746 = (int) D.18745;
      D.18747 = *__s2;
      D.18748 = (int) D.18747;
      __result = D.18746 - D.18748;
      {
        if (__s2_len != 0) goto <D.18749>; else goto <D.18750>;
        <D.18749>:
        if (__result == 0) goto <D.18751>; else goto <D.18752>;
        <D.18751>:
        D.18753 = &MEM[(void *)"CheckElevatedPermissions" + 1B];
        D.18754 = *D.18753;
        D.18755 = (int) D.18754;
        D.18756 = __s2 + 1;
        D.18757 = *D.18756;
        D.18758 = (int) D.18757;
        __result = D.18755 - D.18758;
        if (__s2_len > 1) goto <D.18759>; else goto <D.18760>;
        <D.18759>:
        if (__result == 0) goto <D.18761>; else goto <D.18762>;
        <D.18761>:
        D.18763 = &MEM[(void *)"CheckElevatedPermissions" + 2B];
        D.18764 = *D.18763;
        D.18765 = (int) D.18764;
        D.18766 = __s2 + 2;
        D.18767 = *D.18766;
        D.18768 = (int) D.18767;
        __result = D.18765 - D.18768;
        if (__s2_len > 2) goto <D.18769>; else goto <D.18770>;
        <D.18769>:
        if (__result == 0) goto <D.18771>; else goto <D.18772>;
        <D.18771>:
        D.18773 = &MEM[(void *)"CheckElevatedPermissions" + 3B];
        D.18774 = *D.18773;
        D.18775 = (int) D.18774;
        D.18776 = __s2 + 3;
        D.18777 = *D.18776;
        D.18778 = (int) D.18777;
        __result = D.18775 - D.18778;
        <D.18772>:
        <D.18770>:
        <D.18762>:
        <D.18760>:
        <D.18752>:
        <D.18750>:
      }
      D.18248 = __result;
    }
    iftmp.9 = -D.18248;
    goto <D.18779>;
    <D.18743>:
    D.18738 = m->name;
    iftmp.9 = __builtin_strcmp (D.18738, "CheckElevatedPermissions");
    <D.18779>:
    D.18249 = iftmp.9;
  }
  if (D.18249 != 0) goto <D.18780>; else goto <D.18781>;
  <D.18780>:
  D.18608 = 0;
  return D.18608;
  <D.18781>:
  <D.18740>:
  cookie->depth = 1;
  goto <D.18250>;
  <D.18251>:
  cookie->depth = 2;
  goto <D.18250>;
  <D.18252>:
  D.18614 = cookie->depth;
  D.18782 = D.18614 + 1;
  cookie->depth = D.18782;
  D.18783 = mono_security_core_clr_method_level (m, 1);
  if (D.18783 == 0) goto <D.18250>; else goto <D.18784>;
  <D.18784>:
  cookie->caller = m;
  D.18608 = 1;
  return D.18608;
  <D.18250>:
  D.18608 = 0;
  return D.18608;
}


mono_security_core_clr_ensure_reflection_access_field (struct MonoClassField * field)
{
  <unnamed type> D.18786;
  <unnamed type> D.18789;
  unsigned int D.18790;
  struct MonoClass * D.18793;
  struct MonoImage * D.18794;
  int D.18795;
  struct MonoClass * D.18798;
  <unnamed type> D.18799;
  struct MonoException * D.18802;
  int D.18803;
  struct MonoException * D.18806;
  struct MonoMethod * caller;

  caller = get_reflection_caller ();
  D.18786 = mono_security_core_clr_method_level (caller, 1);
  if (D.18786 != 0) goto <D.18787>; else goto <D.18788>;
  <D.18787>:
  return;
  <D.18788>:
  D.18789 = mono_security_core_clr_get_options ();
  D.18790 = D.18789 & 1;
  if (D.18790 != 0) goto <D.18791>; else goto <D.18792>;
  <D.18791>:
  D.18793 = mono_field_get_parent (field);
  D.18794 = D.18793->image;
  D.18795 = mono_security_core_clr_is_platform_image (D.18794);
  if (D.18795 == 0) goto <D.18796>; else goto <D.18797>;
  <D.18796>:
  return;
  <D.18797>:
  <D.18792>:
  D.18798 = mono_field_get_parent (field);
  D.18799 = mono_security_core_clr_class_level (D.18798);
  if (D.18799 == 2) goto <D.18800>; else goto <D.18801>;
  <D.18800>:
  D.18802 = get_field_access_exception ("Transparent method %s cannot get or set Critical field %s.", caller, field);
  mono_raise_exception (D.18802);
  <D.18801>:
  D.18803 = check_field_access (caller, field);
  if (D.18803 == 0) goto <D.18804>; else goto <D.18805>;
  <D.18804>:
  D.18806 = get_field_access_exception ("Transparent method %s cannot get or set private/internal field %s.", caller, field);
  mono_raise_exception (D.18806);
  <D.18805>:
}


get_reflection_caller ()
{
  struct MonoMethod * m.10;
  _Bool D.18809;
  long int D.18810;
  long int D.18811;
  struct MonoMethod * D.18814;
  struct MonoMethod * m;

  try
    {
      m = 0B;
      mono_stack_walk_no_il (get_caller_no_reflection_related, &m);
      m.10 = m;
      D.18809 = m.10 == 0B;
      D.18810 = (long int) D.18809;
      D.18811 = __builtin_expect (D.18810, 0);
      if (D.18811 != 0) goto <D.18812>; else goto <D.18813>;
      <D.18812>:
      mono_trace (16, 64, "No caller outside reflection was found");
      <D.18813>:
      D.18814 = m;
      return D.18814;
    }
  finally
    {
      m = {CLOBBER};
    }
}


get_caller_no_reflection_related (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.18819;
  long unsigned int D.18820;
  long unsigned int D.18821;
  struct MonoClass * D.18824;
  char D.18828;
  struct MonoImage * D.18829;
  int D.18830;
  int D.18114;
  int iftmp.11;
  int D.18113;
  const char[18] * D.18836;
  unsigned char D.18837;
  int D.18838;
  unsigned char D.18839;
  int D.18840;
  const unsigned char * D.18845;
  unsigned char D.18846;
  int D.18847;
  const unsigned char * D.18848;
  unsigned char D.18849;
  int D.18850;
  const unsigned char * D.18855;
  unsigned char D.18856;
  int D.18857;
  const unsigned char * D.18858;
  unsigned char D.18859;
  int D.18860;
  const unsigned char * D.18865;
  unsigned char D.18866;
  int D.18867;
  const unsigned char * D.18868;
  unsigned char D.18869;
  int D.18870;
  int D.18123;
  int iftmp.12;
  int D.18122;
  const char[23] * D.18877;
  unsigned char D.18878;
  int D.18879;
  unsigned char D.18880;
  int D.18881;
  const unsigned char * D.18886;
  unsigned char D.18887;
  int D.18888;
  const unsigned char * D.18889;
  unsigned char D.18890;
  int D.18891;
  const unsigned char * D.18896;
  unsigned char D.18897;
  int D.18898;
  const unsigned char * D.18899;
  unsigned char D.18900;
  int D.18901;
  const unsigned char * D.18906;
  unsigned char D.18907;
  int D.18908;
  const unsigned char * D.18909;
  unsigned char D.18910;
  int D.18911;
  int D.18132;
  int iftmp.13;
  int D.18131;
  const char[7] * D.18918;
  unsigned char D.18919;
  int D.18920;
  unsigned char D.18921;
  int D.18922;
  const unsigned char * D.18927;
  unsigned char D.18928;
  int D.18929;
  const unsigned char * D.18930;
  unsigned char D.18931;
  int D.18932;
  const unsigned char * D.18937;
  unsigned char D.18938;
  int D.18939;
  const unsigned char * D.18940;
  unsigned char D.18941;
  int D.18942;
  const unsigned char * D.18947;
  unsigned char D.18948;
  int D.18949;
  const unsigned char * D.18950;
  unsigned char D.18951;
  int D.18952;
  char D.18956;
  int D.18142;
  int iftmp.14;
  int D.18141;
  const char[10] * D.18962;
  unsigned char D.18963;
  int D.18964;
  unsigned char D.18965;
  int D.18966;
  const unsigned char * D.18971;
  unsigned char D.18972;
  int D.18973;
  const unsigned char * D.18974;
  unsigned char D.18975;
  int D.18976;
  const unsigned char * D.18981;
  unsigned char D.18982;
  int D.18983;
  const unsigned char * D.18984;
  unsigned char D.18985;
  int D.18986;
  const unsigned char * D.18991;
  unsigned char D.18992;
  int D.18993;
  const unsigned char * D.18994;
  unsigned char D.18995;
  int D.18996;
  int D.18151;
  int iftmp.15;
  int D.18150;
  const char[5] * D.19007;
  unsigned char D.19008;
  int D.19009;
  unsigned char D.19010;
  int D.19011;
  const unsigned char * D.19016;
  unsigned char D.19017;
  int D.19018;
  const unsigned char * D.19019;
  unsigned char D.19020;
  int D.19021;
  const unsigned char * D.19026;
  unsigned char D.19027;
  int D.19028;
  const unsigned char * D.19029;
  unsigned char D.19030;
  int D.19031;
  const unsigned char * D.19036;
  unsigned char D.19037;
  int D.19038;
  const unsigned char * D.19039;
  unsigned char D.19040;
  int D.19041;
  int D.18160;
  int iftmp.16;
  int D.18159;
  const char[9] * D.19047;
  unsigned char D.19048;
  int D.19049;
  unsigned char D.19050;
  int D.19051;
  const unsigned char * D.19056;
  unsigned char D.19057;
  int D.19058;
  const unsigned char * D.19059;
  unsigned char D.19060;
  int D.19061;
  const unsigned char * D.19066;
  unsigned char D.19067;
  int D.19068;
  const unsigned char * D.19069;
  unsigned char D.19070;
  int D.19071;
  const unsigned char * D.19076;
  unsigned char D.19077;
  int D.19078;
  const unsigned char * D.19079;
  unsigned char D.19080;
  int D.19081;
  int D.18169;
  int iftmp.17;
  int D.18168;
  const char[13] * D.19086;
  unsigned char D.19087;
  int D.19088;
  unsigned char D.19089;
  int D.19090;
  const unsigned char * D.19095;
  unsigned char D.19096;
  int D.19097;
  const unsigned char * D.19098;
  unsigned char D.19099;
  int D.19100;
  const unsigned char * D.19105;
  unsigned char D.19106;
  int D.19107;
  const unsigned char * D.19108;
  unsigned char D.19109;
  int D.19110;
  const unsigned char * D.19115;
  unsigned char D.19116;
  int D.19117;
  const unsigned char * D.19118;
  unsigned char D.19119;
  int D.19120;
  const char * D.19122;
  int D.18178;
  int iftmp.18;
  int D.18177;
  const char[9] * D.19132;
  unsigned char D.19133;
  int D.19134;
  unsigned char D.19135;
  int D.19136;
  const unsigned char * D.19141;
  unsigned char D.19142;
  int D.19143;
  const unsigned char * D.19144;
  unsigned char D.19145;
  int D.19146;
  const unsigned char * D.19151;
  unsigned char D.19152;
  int D.19153;
  const unsigned char * D.19154;
  unsigned char D.19155;
  int D.19156;
  const unsigned char * D.19161;
  unsigned char D.19162;
  int D.19163;
  const unsigned char * D.19164;
  unsigned char D.19165;
  int D.19166;
  int D.18187;
  int iftmp.19;
  int D.18186;
  const char[18] * D.19172;
  unsigned char D.19173;
  int D.19174;
  unsigned char D.19175;
  int D.19176;
  const unsigned char * D.19181;
  unsigned char D.19182;
  int D.19183;
  const unsigned char * D.19184;
  unsigned char D.19185;
  int D.19186;
  const unsigned char * D.19191;
  unsigned char D.19192;
  int D.19193;
  const unsigned char * D.19194;
  unsigned char D.19195;
  int D.19196;
  const unsigned char * D.19201;
  unsigned char D.19202;
  int D.19203;
  const unsigned char * D.19204;
  unsigned char D.19205;
  int D.19206;
  int D.18196;
  int iftmp.20;
  int D.18195;
  const char[14] * D.19211;
  unsigned char D.19212;
  int D.19213;
  unsigned char D.19214;
  int D.19215;
  const unsigned char * D.19220;
  unsigned char D.19221;
  int D.19222;
  const unsigned char * D.19223;
  unsigned char D.19224;
  int D.19225;
  const unsigned char * D.19230;
  unsigned char D.19231;
  int D.19232;
  const unsigned char * D.19233;
  unsigned char D.19234;
  int D.19235;
  const unsigned char * D.19240;
  unsigned char D.19241;
  int D.19242;
  const unsigned char * D.19243;
  unsigned char D.19244;
  int D.19245;
  struct MonoMethod * D.19249;
  struct MonoMethod * * dest;
  const char * ns;

  dest = data;
  if (managed == 0) goto <D.18817>; else goto <D.18818>;
  <D.18817>:
  D.18819 = 0;
  return D.18819;
  <D.18818>:
  D.18820 = BIT_FIELD_REF <*m, 64, 256>;
  D.18821 = D.18820 & 124;
  if (D.18821 != 0) goto <D.18822>; else goto <D.18823>;
  <D.18822>:
  D.18819 = 0;
  return D.18819;
  <D.18823>:
  D.18824 = m->klass;
  ns = D.18824->name_space;
  if (ns == 0B) goto <D.18825>; else goto <D.18827>;
  <D.18827>:
  D.18828 = *ns;
  if (D.18828 != 83) goto <D.18825>; else goto <D.18826>;
  <D.18825>:
  *dest = m;
  D.18819 = 1;
  return D.18819;
  <D.18826>:
  D.18824 = m->klass;
  D.18829 = D.18824->image;
  D.18830 = mono_security_core_clr_is_platform_image (D.18829);
  if (D.18830 == 0) goto <D.18831>; else goto <D.18832>;
  <D.18831>:
  *dest = m;
  D.18819 = 1;
  return D.18819;
  <D.18832>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ns;
      D.18836 = "System.Reflection";
      D.18837 = MEM[(const unsigned char *)D.18836];
      D.18838 = (int) D.18837;
      D.18839 = *__s2;
      D.18840 = (int) D.18839;
      __result = D.18838 - D.18840;
      {
        if (__s2_len != 0) goto <D.18841>; else goto <D.18842>;
        <D.18841>:
        if (__result == 0) goto <D.18843>; else goto <D.18844>;
        <D.18843>:
        D.18845 = &MEM[(void *)"System.Reflection" + 1B];
        D.18846 = *D.18845;
        D.18847 = (int) D.18846;
        D.18848 = __s2 + 1;
        D.18849 = *D.18848;
        D.18850 = (int) D.18849;
        __result = D.18847 - D.18850;
        if (__s2_len > 1) goto <D.18851>; else goto <D.18852>;
        <D.18851>:
        if (__result == 0) goto <D.18853>; else goto <D.18854>;
        <D.18853>:
        D.18855 = &MEM[(void *)"System.Reflection" + 2B];
        D.18856 = *D.18855;
        D.18857 = (int) D.18856;
        D.18858 = __s2 + 2;
        D.18859 = *D.18858;
        D.18860 = (int) D.18859;
        __result = D.18857 - D.18860;
        if (__s2_len > 2) goto <D.18861>; else goto <D.18862>;
        <D.18861>:
        if (__result == 0) goto <D.18863>; else goto <D.18864>;
        <D.18863>:
        D.18865 = &MEM[(void *)"System.Reflection" + 3B];
        D.18866 = *D.18865;
        D.18867 = (int) D.18866;
        D.18868 = __s2 + 3;
        D.18869 = *D.18868;
        D.18870 = (int) D.18869;
        __result = D.18867 - D.18870;
        <D.18864>:
        <D.18862>:
        <D.18854>:
        <D.18852>:
        <D.18844>:
        <D.18842>:
      }
      D.18113 = __result;
    }
    iftmp.11 = -D.18113;
    goto <D.18871>;
    <D.18835>:
    iftmp.11 = __builtin_strcmp (ns, "System.Reflection");
    <D.18871>:
    D.18114 = iftmp.11;
  }
  if (D.18114 == 0) goto <D.18872>; else goto <D.18873>;
  <D.18872>:
  D.18819 = 0;
  return D.18819;
  <D.18873>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ns;
      D.18877 = "System.Reflection.Emit";
      D.18878 = MEM[(const unsigned char *)D.18877];
      D.18879 = (int) D.18878;
      D.18880 = *__s2;
      D.18881 = (int) D.18880;
      __result = D.18879 - D.18881;
      {
        if (__s2_len != 0) goto <D.18882>; else goto <D.18883>;
        <D.18882>:
        if (__result == 0) goto <D.18884>; else goto <D.18885>;
        <D.18884>:
        D.18886 = &MEM[(void *)"System.Reflection.Emit" + 1B];
        D.18887 = *D.18886;
        D.18888 = (int) D.18887;
        D.18889 = __s2 + 1;
        D.18890 = *D.18889;
        D.18891 = (int) D.18890;
        __result = D.18888 - D.18891;
        if (__s2_len > 1) goto <D.18892>; else goto <D.18893>;
        <D.18892>:
        if (__result == 0) goto <D.18894>; else goto <D.18895>;
        <D.18894>:
        D.18896 = &MEM[(void *)"System.Reflection.Emit" + 2B];
        D.18897 = *D.18896;
        D.18898 = (int) D.18897;
        D.18899 = __s2 + 2;
        D.18900 = *D.18899;
        D.18901 = (int) D.18900;
        __result = D.18898 - D.18901;
        if (__s2_len > 2) goto <D.18902>; else goto <D.18903>;
        <D.18902>:
        if (__result == 0) goto <D.18904>; else goto <D.18905>;
        <D.18904>:
        D.18906 = &MEM[(void *)"System.Reflection.Emit" + 3B];
        D.18907 = *D.18906;
        D.18908 = (int) D.18907;
        D.18909 = __s2 + 3;
        D.18910 = *D.18909;
        D.18911 = (int) D.18910;
        __result = D.18908 - D.18911;
        <D.18905>:
        <D.18903>:
        <D.18895>:
        <D.18893>:
        <D.18885>:
        <D.18883>:
      }
      D.18122 = __result;
    }
    iftmp.12 = -D.18122;
    goto <D.18912>;
    <D.18876>:
    iftmp.12 = __builtin_strcmp (ns, "System.Reflection.Emit");
    <D.18912>:
    D.18123 = iftmp.12;
  }
  if (D.18123 == 0) goto <D.18913>; else goto <D.18914>;
  <D.18913>:
  D.18819 = 0;
  return D.18819;
  <D.18914>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ns;
      D.18918 = "System";
      D.18919 = MEM[(const unsigned char *)D.18918];
      D.18920 = (int) D.18919;
      D.18921 = *__s2;
      D.18922 = (int) D.18921;
      __result = D.18920 - D.18922;
      {
        if (__s2_len != 0) goto <D.18923>; else goto <D.18924>;
        <D.18923>:
        if (__result == 0) goto <D.18925>; else goto <D.18926>;
        <D.18925>:
        D.18927 = &MEM[(void *)"System" + 1B];
        D.18928 = *D.18927;
        D.18929 = (int) D.18928;
        D.18930 = __s2 + 1;
        D.18931 = *D.18930;
        D.18932 = (int) D.18931;
        __result = D.18929 - D.18932;
        if (__s2_len > 1) goto <D.18933>; else goto <D.18934>;
        <D.18933>:
        if (__result == 0) goto <D.18935>; else goto <D.18936>;
        <D.18935>:
        D.18937 = &MEM[(void *)"System" + 2B];
        D.18938 = *D.18937;
        D.18939 = (int) D.18938;
        D.18940 = __s2 + 2;
        D.18941 = *D.18940;
        D.18942 = (int) D.18941;
        __result = D.18939 - D.18942;
        if (__s2_len > 2) goto <D.18943>; else goto <D.18944>;
        <D.18943>:
        if (__result == 0) goto <D.18945>; else goto <D.18946>;
        <D.18945>:
        D.18947 = &MEM[(void *)"System" + 3B];
        D.18948 = *D.18947;
        D.18949 = (int) D.18948;
        D.18950 = __s2 + 3;
        D.18951 = *D.18950;
        D.18952 = (int) D.18951;
        __result = D.18949 - D.18952;
        <D.18946>:
        <D.18944>:
        <D.18936>:
        <D.18934>:
        <D.18926>:
        <D.18924>:
      }
      D.18131 = __result;
    }
    iftmp.13 = -D.18131;
    goto <D.18953>;
    <D.18917>:
    iftmp.13 = __builtin_strcmp (ns, "System");
    <D.18953>:
    D.18132 = iftmp.13;
  }
  if (D.18132 == 0) goto <D.18954>; else goto <D.18955>;
  <D.18954>:
  {
    const char * kname;

    D.18824 = m->klass;
    kname = D.18824->name;
    D.18956 = *kname;
    if (D.18956 == 65) goto <D.18957>; else goto <D.18958>;
    <D.18957>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.18962 = "Activator";
        D.18963 = MEM[(const unsigned char *)D.18962];
        D.18964 = (int) D.18963;
        D.18965 = *__s2;
        D.18966 = (int) D.18965;
        __result = D.18964 - D.18966;
        {
          if (__s2_len != 0) goto <D.18967>; else goto <D.18968>;
          <D.18967>:
          if (__result == 0) goto <D.18969>; else goto <D.18970>;
          <D.18969>:
          D.18971 = &MEM[(void *)"Activator" + 1B];
          D.18972 = *D.18971;
          D.18973 = (int) D.18972;
          D.18974 = __s2 + 1;
          D.18975 = *D.18974;
          D.18976 = (int) D.18975;
          __result = D.18973 - D.18976;
          if (__s2_len > 1) goto <D.18977>; else goto <D.18978>;
          <D.18977>:
          if (__result == 0) goto <D.18979>; else goto <D.18980>;
          <D.18979>:
          D.18981 = &MEM[(void *)"Activator" + 2B];
          D.18982 = *D.18981;
          D.18983 = (int) D.18982;
          D.18984 = __s2 + 2;
          D.18985 = *D.18984;
          D.18986 = (int) D.18985;
          __result = D.18983 - D.18986;
          if (__s2_len > 2) goto <D.18987>; else goto <D.18988>;
          <D.18987>:
          if (__result == 0) goto <D.18989>; else goto <D.18990>;
          <D.18989>:
          D.18991 = &MEM[(void *)"Activator" + 3B];
          D.18992 = *D.18991;
          D.18993 = (int) D.18992;
          D.18994 = __s2 + 3;
          D.18995 = *D.18994;
          D.18996 = (int) D.18995;
          __result = D.18993 - D.18996;
          <D.18990>:
          <D.18988>:
          <D.18980>:
          <D.18978>:
          <D.18970>:
          <D.18968>:
        }
        D.18141 = __result;
      }
      iftmp.14 = -D.18141;
      goto <D.18997>;
      <D.18961>:
      iftmp.14 = __builtin_strcmp (kname, "Activator");
      <D.18997>:
      D.18142 = iftmp.14;
    }
    if (D.18142 == 0) goto <D.18998>; else goto <D.18999>;
    <D.18998>:
    D.18819 = 0;
    return D.18819;
    <D.18999>:
    <D.18958>:
    D.18956 = *kname;
    if (D.18956 == 84) goto <D.19003>; else goto <D.19000>;
    <D.19003>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.19007 = "Type";
        D.19008 = MEM[(const unsigned char *)D.19007];
        D.19009 = (int) D.19008;
        D.19010 = *__s2;
        D.19011 = (int) D.19010;
        __result = D.19009 - D.19011;
        {
          if (__s2_len != 0) goto <D.19012>; else goto <D.19013>;
          <D.19012>:
          if (__result == 0) goto <D.19014>; else goto <D.19015>;
          <D.19014>:
          D.19016 = &MEM[(void *)"Type" + 1B];
          D.19017 = *D.19016;
          D.19018 = (int) D.19017;
          D.19019 = __s2 + 1;
          D.19020 = *D.19019;
          D.19021 = (int) D.19020;
          __result = D.19018 - D.19021;
          if (__s2_len > 1) goto <D.19022>; else goto <D.19023>;
          <D.19022>:
          if (__result == 0) goto <D.19024>; else goto <D.19025>;
          <D.19024>:
          D.19026 = &MEM[(void *)"Type" + 2B];
          D.19027 = *D.19026;
          D.19028 = (int) D.19027;
          D.19029 = __s2 + 2;
          D.19030 = *D.19029;
          D.19031 = (int) D.19030;
          __result = D.19028 - D.19031;
          if (__s2_len > 2) goto <D.19032>; else goto <D.19033>;
          <D.19032>:
          if (__result == 0) goto <D.19034>; else goto <D.19035>;
          <D.19034>:
          D.19036 = &MEM[(void *)"Type" + 3B];
          D.19037 = *D.19036;
          D.19038 = (int) D.19037;
          D.19039 = __s2 + 3;
          D.19040 = *D.19039;
          D.19041 = (int) D.19040;
          __result = D.19038 - D.19041;
          <D.19035>:
          <D.19033>:
          <D.19025>:
          <D.19023>:
          <D.19015>:
          <D.19013>:
        }
        D.18150 = __result;
      }
      iftmp.15 = -D.18150;
      goto <D.19042>;
      <D.19006>:
      iftmp.15 = __builtin_strcmp (kname, "Type");
      <D.19042>:
      D.18151 = iftmp.15;
    }
    if (D.18151 == 0) goto <D.19001>; else goto <D.19000>;
    <D.19000>:
    D.18956 = *kname;
    if (D.18956 == 77) goto <D.19043>; else goto <D.19002>;
    <D.19043>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.19047 = "MonoType";
        D.19048 = MEM[(const unsigned char *)D.19047];
        D.19049 = (int) D.19048;
        D.19050 = *__s2;
        D.19051 = (int) D.19050;
        __result = D.19049 - D.19051;
        {
          if (__s2_len != 0) goto <D.19052>; else goto <D.19053>;
          <D.19052>:
          if (__result == 0) goto <D.19054>; else goto <D.19055>;
          <D.19054>:
          D.19056 = &MEM[(void *)"MonoType" + 1B];
          D.19057 = *D.19056;
          D.19058 = (int) D.19057;
          D.19059 = __s2 + 1;
          D.19060 = *D.19059;
          D.19061 = (int) D.19060;
          __result = D.19058 - D.19061;
          if (__s2_len > 1) goto <D.19062>; else goto <D.19063>;
          <D.19062>:
          if (__result == 0) goto <D.19064>; else goto <D.19065>;
          <D.19064>:
          D.19066 = &MEM[(void *)"MonoType" + 2B];
          D.19067 = *D.19066;
          D.19068 = (int) D.19067;
          D.19069 = __s2 + 2;
          D.19070 = *D.19069;
          D.19071 = (int) D.19070;
          __result = D.19068 - D.19071;
          if (__s2_len > 2) goto <D.19072>; else goto <D.19073>;
          <D.19072>:
          if (__result == 0) goto <D.19074>; else goto <D.19075>;
          <D.19074>:
          D.19076 = &MEM[(void *)"MonoType" + 3B];
          D.19077 = *D.19076;
          D.19078 = (int) D.19077;
          D.19079 = __s2 + 3;
          D.19080 = *D.19079;
          D.19081 = (int) D.19080;
          __result = D.19078 - D.19081;
          <D.19075>:
          <D.19073>:
          <D.19065>:
          <D.19063>:
          <D.19055>:
          <D.19053>:
        }
        D.18159 = __result;
      }
      iftmp.16 = -D.18159;
      goto <D.19082>;
      <D.19046>:
      iftmp.16 = __builtin_strcmp (kname, "MonoType");
      <D.19082>:
      D.18160 = iftmp.16;
    }
    if (D.18160 == 0) goto <D.19001>; else goto <D.19002>;
    <D.19001>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.19086 = "InvokeMember";
        D.19087 = MEM[(const unsigned char *)D.19086];
        D.19088 = (int) D.19087;
        D.19089 = *__s2;
        D.19090 = (int) D.19089;
        __result = D.19088 - D.19090;
        {
          if (__s2_len != 0) goto <D.19091>; else goto <D.19092>;
          <D.19091>:
          if (__result == 0) goto <D.19093>; else goto <D.19094>;
          <D.19093>:
          D.19095 = &MEM[(void *)"InvokeMember" + 1B];
          D.19096 = *D.19095;
          D.19097 = (int) D.19096;
          D.19098 = __s2 + 1;
          D.19099 = *D.19098;
          D.19100 = (int) D.19099;
          __result = D.19097 - D.19100;
          if (__s2_len > 1) goto <D.19101>; else goto <D.19102>;
          <D.19101>:
          if (__result == 0) goto <D.19103>; else goto <D.19104>;
          <D.19103>:
          D.19105 = &MEM[(void *)"InvokeMember" + 2B];
          D.19106 = *D.19105;
          D.19107 = (int) D.19106;
          D.19108 = __s2 + 2;
          D.19109 = *D.19108;
          D.19110 = (int) D.19109;
          __result = D.19107 - D.19110;
          if (__s2_len > 2) goto <D.19111>; else goto <D.19112>;
          <D.19111>:
          if (__result == 0) goto <D.19113>; else goto <D.19114>;
          <D.19113>:
          D.19115 = &MEM[(void *)"InvokeMember" + 3B];
          D.19116 = *D.19115;
          D.19117 = (int) D.19116;
          D.19118 = __s2 + 3;
          D.19119 = *D.19118;
          D.19120 = (int) D.19119;
          __result = D.19117 - D.19120;
          <D.19114>:
          <D.19112>:
          <D.19104>:
          <D.19102>:
          <D.19094>:
          <D.19092>:
        }
        D.18168 = __result;
      }
      iftmp.17 = -D.18168;
      goto <D.19121>;
      <D.19085>:
      D.19122 = m->name;
      iftmp.17 = __builtin_strcmp (D.19122, "InvokeMember");
      <D.19121>:
      D.18169 = iftmp.17;
    }
    if (D.18169 == 0) goto <D.19123>; else goto <D.19124>;
    <D.19123>:
    D.18819 = 0;
    return D.18819;
    <D.19124>:
    <D.19002>:
    D.18956 = *kname;
    if (D.18956 == 68) goto <D.19128>; else goto <D.19125>;
    <D.19128>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.19132 = "Delegate";
        D.19133 = MEM[(const unsigned char *)D.19132];
        D.19134 = (int) D.19133;
        D.19135 = *__s2;
        D.19136 = (int) D.19135;
        __result = D.19134 - D.19136;
        {
          if (__s2_len != 0) goto <D.19137>; else goto <D.19138>;
          <D.19137>:
          if (__result == 0) goto <D.19139>; else goto <D.19140>;
          <D.19139>:
          D.19141 = &MEM[(void *)"Delegate" + 1B];
          D.19142 = *D.19141;
          D.19143 = (int) D.19142;
          D.19144 = __s2 + 1;
          D.19145 = *D.19144;
          D.19146 = (int) D.19145;
          __result = D.19143 - D.19146;
          if (__s2_len > 1) goto <D.19147>; else goto <D.19148>;
          <D.19147>:
          if (__result == 0) goto <D.19149>; else goto <D.19150>;
          <D.19149>:
          D.19151 = &MEM[(void *)"Delegate" + 2B];
          D.19152 = *D.19151;
          D.19153 = (int) D.19152;
          D.19154 = __s2 + 2;
          D.19155 = *D.19154;
          D.19156 = (int) D.19155;
          __result = D.19153 - D.19156;
          if (__s2_len > 2) goto <D.19157>; else goto <D.19158>;
          <D.19157>:
          if (__result == 0) goto <D.19159>; else goto <D.19160>;
          <D.19159>:
          D.19161 = &MEM[(void *)"Delegate" + 3B];
          D.19162 = *D.19161;
          D.19163 = (int) D.19162;
          D.19164 = __s2 + 3;
          D.19165 = *D.19164;
          D.19166 = (int) D.19165;
          __result = D.19163 - D.19166;
          <D.19160>:
          <D.19158>:
          <D.19150>:
          <D.19148>:
          <D.19140>:
          <D.19138>:
        }
        D.18177 = __result;
      }
      iftmp.18 = -D.18177;
      goto <D.19167>;
      <D.19131>:
      iftmp.18 = __builtin_strcmp (kname, "Delegate");
      <D.19167>:
      D.18178 = iftmp.18;
    }
    if (D.18178 == 0) goto <D.19126>; else goto <D.19125>;
    <D.19125>:
    D.18956 = *kname;
    if (D.18956 == 77) goto <D.19168>; else goto <D.19127>;
    <D.19168>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.19172 = "MulticastDelegate";
        D.19173 = MEM[(const unsigned char *)D.19172];
        D.19174 = (int) D.19173;
        D.19175 = *__s2;
        D.19176 = (int) D.19175;
        __result = D.19174 - D.19176;
        {
          if (__s2_len != 0) goto <D.19177>; else goto <D.19178>;
          <D.19177>:
          if (__result == 0) goto <D.19179>; else goto <D.19180>;
          <D.19179>:
          D.19181 = &MEM[(void *)"MulticastDelegate" + 1B];
          D.19182 = *D.19181;
          D.19183 = (int) D.19182;
          D.19184 = __s2 + 1;
          D.19185 = *D.19184;
          D.19186 = (int) D.19185;
          __result = D.19183 - D.19186;
          if (__s2_len > 1) goto <D.19187>; else goto <D.19188>;
          <D.19187>:
          if (__result == 0) goto <D.19189>; else goto <D.19190>;
          <D.19189>:
          D.19191 = &MEM[(void *)"MulticastDelegate" + 2B];
          D.19192 = *D.19191;
          D.19193 = (int) D.19192;
          D.19194 = __s2 + 2;
          D.19195 = *D.19194;
          D.19196 = (int) D.19195;
          __result = D.19193 - D.19196;
          if (__s2_len > 2) goto <D.19197>; else goto <D.19198>;
          <D.19197>:
          if (__result == 0) goto <D.19199>; else goto <D.19200>;
          <D.19199>:
          D.19201 = &MEM[(void *)"MulticastDelegate" + 3B];
          D.19202 = *D.19201;
          D.19203 = (int) D.19202;
          D.19204 = __s2 + 3;
          D.19205 = *D.19204;
          D.19206 = (int) D.19205;
          __result = D.19203 - D.19206;
          <D.19200>:
          <D.19198>:
          <D.19190>:
          <D.19188>:
          <D.19180>:
          <D.19178>:
        }
        D.18186 = __result;
      }
      iftmp.19 = -D.18186;
      goto <D.19207>;
      <D.19171>:
      iftmp.19 = __builtin_strcmp (kname, "MulticastDelegate");
      <D.19207>:
      D.18187 = iftmp.19;
    }
    if (D.18187 == 0) goto <D.19126>; else goto <D.19127>;
    <D.19126>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.19211 = "DynamicInvoke";
        D.19212 = MEM[(const unsigned char *)D.19211];
        D.19213 = (int) D.19212;
        D.19214 = *__s2;
        D.19215 = (int) D.19214;
        __result = D.19213 - D.19215;
        {
          if (__s2_len != 0) goto <D.19216>; else goto <D.19217>;
          <D.19216>:
          if (__result == 0) goto <D.19218>; else goto <D.19219>;
          <D.19218>:
          D.19220 = &MEM[(void *)"DynamicInvoke" + 1B];
          D.19221 = *D.19220;
          D.19222 = (int) D.19221;
          D.19223 = __s2 + 1;
          D.19224 = *D.19223;
          D.19225 = (int) D.19224;
          __result = D.19222 - D.19225;
          if (__s2_len > 1) goto <D.19226>; else goto <D.19227>;
          <D.19226>:
          if (__result == 0) goto <D.19228>; else goto <D.19229>;
          <D.19228>:
          D.19230 = &MEM[(void *)"DynamicInvoke" + 2B];
          D.19231 = *D.19230;
          D.19232 = (int) D.19231;
          D.19233 = __s2 + 2;
          D.19234 = *D.19233;
          D.19235 = (int) D.19234;
          __result = D.19232 - D.19235;
          if (__s2_len > 2) goto <D.19236>; else goto <D.19237>;
          <D.19236>:
          if (__result == 0) goto <D.19238>; else goto <D.19239>;
          <D.19238>:
          D.19240 = &MEM[(void *)"DynamicInvoke" + 3B];
          D.19241 = *D.19240;
          D.19242 = (int) D.19241;
          D.19243 = __s2 + 3;
          D.19244 = *D.19243;
          D.19245 = (int) D.19244;
          __result = D.19242 - D.19245;
          <D.19239>:
          <D.19237>:
          <D.19229>:
          <D.19227>:
          <D.19219>:
          <D.19217>:
        }
        D.18195 = __result;
      }
      iftmp.20 = -D.18195;
      goto <D.19246>;
      <D.19210>:
      D.19122 = m->name;
      iftmp.20 = __builtin_strcmp (D.19122, "DynamicInvoke");
      <D.19246>:
      D.18196 = iftmp.20;
    }
    if (D.18196 != 0) goto <D.19247>; else goto <D.19248>;
    <D.19247>:
    D.18819 = 0;
    return D.18819;
    <D.19248>:
    <D.19127>:
  }
  <D.18955>:
  D.19249 = *dest;
  if (D.19249 == m) goto <D.19250>; else goto <D.19251>;
  <D.19250>:
  *dest = 0B;
  D.18819 = 0;
  return D.18819;
  <D.19251>:
  *dest = m;
  D.18819 = 1;
  return D.18819;
}


check_field_access (struct MonoMethod * caller, struct MonoClassField * field)
{
  int D.19255;
  gboolean D.19258;
  struct MonoClass * iftmp.21;
  unsigned int D.19260;
  unsigned int D.19261;

  if (caller != 0B) goto <D.19253>; else goto <D.19254>;
  <D.19253>:
  {
    struct MonoError error;
    struct MonoClass * klass;

    try
      {
        mono_field_get_type_checked (field, &error);
        D.19255 = mono_error_ok (&error);
        if (D.19255 == 0) goto <D.19256>; else goto <D.19257>;
        <D.19256>:
        mono_error_cleanup (&error);
        D.19258 = 0;
        return D.19258;
        <D.19257>:
        D.19260 = mono_field_get_flags (field);
        D.19261 = D.19260 & 16;
        if (D.19261 == 0) goto <D.19262>; else goto <D.19263>;
        <D.19262>:
        iftmp.21 = mono_field_get_parent (field);
        goto <D.19264>;
        <D.19263>:
        iftmp.21 = 0B;
        <D.19264>:
        klass = iftmp.21;
        D.19258 = mono_method_can_access_field_full (caller, field, klass);
        return D.19258;
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.19254>:
  D.19258 = 0;
  return D.19258;
}


get_field_access_exception (const char * format, struct MonoMethod * caller, struct MonoClassField * field)
{
  struct MonoException * D.19267;
  struct MonoException * ex;
  char * caller_name;
  char * field_name;
  char * message;

  caller_name = get_method_full_name (caller);
  field_name = mono_field_full_name (field);
  message = monoeg_g_strdup_printf (format, caller_name, field_name);
  monoeg_g_free (field_name);
  monoeg_g_free (caller_name);
  mono_trace (16, 64, message);
  ex = mono_get_exception_field_access_msg (message);
  monoeg_g_free (message);
  D.19267 = ex;
  return D.19267;
}


mono_security_core_clr_ensure_reflection_access_method (struct MonoMethod * method)
{
  <unnamed type> D.19269;
  <unnamed type> D.19272;
  unsigned int D.19273;
  struct MonoClass * D.19276;
  struct MonoImage * D.19277;
  int D.19278;
  <unnamed type> D.19281;
  struct MonoException * D.19284;
  int D.19285;
  struct MonoException * D.19288;
  struct MonoMethod * caller;

  caller = get_reflection_caller ();
  D.19269 = mono_security_core_clr_method_level (caller, 1);
  if (D.19269 != 0) goto <D.19270>; else goto <D.19271>;
  <D.19270>:
  return;
  <D.19271>:
  D.19272 = mono_security_core_clr_get_options ();
  D.19273 = D.19272 & 1;
  if (D.19273 != 0) goto <D.19274>; else goto <D.19275>;
  <D.19274>:
  D.19276 = method->klass;
  D.19277 = D.19276->image;
  D.19278 = mono_security_core_clr_is_platform_image (D.19277);
  if (D.19278 == 0) goto <D.19279>; else goto <D.19280>;
  <D.19279>:
  return;
  <D.19280>:
  <D.19275>:
  D.19281 = mono_security_core_clr_method_level (method, 1);
  if (D.19281 == 2) goto <D.19282>; else goto <D.19283>;
  <D.19282>:
  D.19284 = get_method_access_exception ("Transparent method %s cannot invoke Critical method %s.", caller, method);
  mono_raise_exception (D.19284);
  <D.19283>:
  D.19285 = check_method_access (caller, method);
  if (D.19285 == 0) goto <D.19286>; else goto <D.19287>;
  <D.19286>:
  D.19288 = get_method_access_exception ("Transparent method %s cannot invoke private/internal method %s.", caller, method);
  mono_raise_exception (D.19288);
  <D.19287>:
}


check_method_access (struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoClass * iftmp.22;
  short unsigned int D.19293;
  int D.19294;
  int D.19295;
  gboolean D.19299;

  if (caller != 0B) goto <D.19290>; else goto <D.19291>;
  <D.19290>:
  {
    struct MonoClass * klass;

    D.19293 = callee->flags;
    D.19294 = (int) D.19293;
    D.19295 = D.19294 & 16;
    if (D.19295 == 0) goto <D.19296>; else goto <D.19297>;
    <D.19296>:
    iftmp.22 = callee->klass;
    goto <D.19298>;
    <D.19297>:
    iftmp.22 = 0B;
    <D.19298>:
    klass = iftmp.22;
    D.19299 = mono_method_can_access_method_full (caller, callee, klass);
    return D.19299;
  }
  <D.19291>:
  D.19299 = 0;
  return D.19299;
}


get_method_access_exception (const char * format, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoException * D.19301;
  struct MonoException * ex;
  char * caller_name;
  char * callee_name;
  char * message;

  caller_name = get_method_full_name (caller);
  callee_name = get_method_full_name (callee);
  message = monoeg_g_strdup_printf (format, caller_name, callee_name);
  monoeg_g_free (callee_name);
  monoeg_g_free (caller_name);
  mono_trace (16, 64, message);
  ex = mono_get_exception_method_access_msg (message);
  monoeg_g_free (message);
  D.19301 = ex;
  return D.19301;
}


mono_security_core_clr_ensure_delegate_creation (struct MonoMethod * method, gboolean throwOnBindFailure)
{
  int D.19303;
  gboolean D.19306;
  <unnamed type> D.19307;
  <unnamed type> D.19310;
  struct MonoException * D.19315;
  <unnamed type> D.19316;
  unsigned int D.19317;
  struct MonoClass * D.19320;
  struct MonoImage * D.19321;
  int D.19322;
  int D.19325;
  struct MonoException * D.19328;
  struct MonoMethod * caller;

  D.19303 = can_avoid_corlib_reflection_delegate_optimization (method);
  if (D.19303 != 0) goto <D.19304>; else goto <D.19305>;
  <D.19304>:
  D.19306 = 1;
  return D.19306;
  <D.19305>:
  caller = get_reflection_caller ();
  D.19307 = mono_security_core_clr_method_level (caller, 1);
  if (D.19307 != 0) goto <D.19308>; else goto <D.19309>;
  <D.19308>:
  D.19306 = 1;
  return D.19306;
  <D.19309>:
  D.19310 = mono_security_core_clr_method_level (method, 1);
  if (D.19310 == 2) goto <D.19311>; else goto <D.19312>;
  <D.19311>:
  if (throwOnBindFailure == 0) goto <D.19313>; else goto <D.19314>;
  <D.19313>:
  D.19306 = 0;
  return D.19306;
  <D.19314>:
  D.19315 = get_argument_exception ("Transparent method %s cannot create a delegate on Critical method %s.", caller, method);
  mono_raise_exception (D.19315);
  <D.19312>:
  D.19316 = mono_security_core_clr_get_options ();
  D.19317 = D.19316 & 2;
  if (D.19317 != 0) goto <D.19318>; else goto <D.19319>;
  <D.19318>:
  D.19320 = method->klass;
  D.19321 = D.19320->image;
  D.19322 = mono_security_core_clr_is_platform_image (D.19321);
  if (D.19322 == 0) goto <D.19323>; else goto <D.19324>;
  <D.19323>:
  D.19306 = 1;
  return D.19306;
  <D.19324>:
  <D.19319>:
  D.19325 = check_method_access (caller, method);
  if (D.19325 == 0) goto <D.19326>; else goto <D.19327>;
  <D.19326>:
  D.19328 = get_method_access_exception ("Transparent method %s cannot create a delegate on private/internal method %s.", caller, method);
  mono_raise_exception (D.19328);
  <D.19327>:
  D.19306 = 1;
  return D.19306;
}


can_avoid_corlib_reflection_delegate_optimization (struct MonoMethod * method)
{
  struct MonoClass * D.19330;
  struct MonoImage * D.19331;
  int D.19332;
  gboolean D.19335;
  int D.18314;
  int iftmp.23;
  int D.18313;
  const char[18] * D.19339;
  unsigned char D.19340;
  int D.19341;
  unsigned char D.19342;
  int D.19343;
  const unsigned char * D.19348;
  unsigned char D.19349;
  int D.19350;
  const unsigned char * D.19351;
  unsigned char D.19352;
  int D.19353;
  const unsigned char * D.19358;
  unsigned char D.19359;
  int D.19360;
  const unsigned char * D.19361;
  unsigned char D.19362;
  int D.19363;
  const unsigned char * D.19368;
  unsigned char D.19369;
  int D.19370;
  const unsigned char * D.19371;
  unsigned char D.19372;
  int D.19373;
  const char * D.19375;
  int D.18323;
  int iftmp.24;
  int D.18322;
  const char[13] * D.19381;
  unsigned char D.19382;
  int D.19383;
  unsigned char D.19384;
  int D.19385;
  const unsigned char * D.19390;
  unsigned char D.19391;
  int D.19392;
  const unsigned char * D.19393;
  unsigned char D.19394;
  int D.19395;
  const unsigned char * D.19400;
  unsigned char D.19401;
  int D.19402;
  const unsigned char * D.19403;
  unsigned char D.19404;
  int D.19405;
  const unsigned char * D.19410;
  unsigned char D.19411;
  int D.19412;
  const unsigned char * D.19413;
  unsigned char D.19414;
  int D.19415;
  const char * D.19417;
  int D.18332;
  int iftmp.25;
  int D.18331;
  const char[19] * D.19425;
  unsigned char D.19426;
  int D.19427;
  unsigned char D.19428;
  int D.19429;
  const unsigned char * D.19434;
  unsigned char D.19435;
  int D.19436;
  const unsigned char * D.19437;
  unsigned char D.19438;
  int D.19439;
  const unsigned char * D.19444;
  unsigned char D.19445;
  int D.19446;
  const unsigned char * D.19447;
  unsigned char D.19448;
  int D.19449;
  const unsigned char * D.19454;
  unsigned char D.19455;
  int D.19456;
  const unsigned char * D.19457;
  unsigned char D.19458;
  int D.19459;
  const char * D.19461;
  int D.18341;
  int iftmp.26;
  int D.18340;
  const char[25] * D.19466;
  unsigned char D.19467;
  int D.19468;
  unsigned char D.19469;
  int D.19470;
  const unsigned char * D.19475;
  unsigned char D.19476;
  int D.19477;
  const unsigned char * D.19478;
  unsigned char D.19479;
  int D.19480;
  const unsigned char * D.19485;
  unsigned char D.19486;
  int D.19487;
  const unsigned char * D.19488;
  unsigned char D.19489;
  int D.19490;
  const unsigned char * D.19495;
  unsigned char D.19496;
  int D.19497;
  const unsigned char * D.19498;
  unsigned char D.19499;
  int D.19500;
  int D.18350;
  int iftmp.27;
  int D.18349;
  const char[10] * D.19506;
  unsigned char D.19507;
  int D.19508;
  unsigned char D.19509;
  int D.19510;
  const unsigned char * D.19515;
  unsigned char D.19516;
  int D.19517;
  const unsigned char * D.19518;
  unsigned char D.19519;
  int D.19520;
  const unsigned char * D.19525;
  unsigned char D.19526;
  int D.19527;
  const unsigned char * D.19528;
  unsigned char D.19529;
  int D.19530;
  const unsigned char * D.19535;
  unsigned char D.19536;
  int D.19537;
  const unsigned char * D.19538;
  unsigned char D.19539;
  int D.19540;
  int D.18359;
  int iftmp.28;
  int D.18358;
  const char[14] * D.19549;
  unsigned char D.19550;
  int D.19551;
  unsigned char D.19552;
  int D.19553;
  const unsigned char * D.19558;
  unsigned char D.19559;
  int D.19560;
  const unsigned char * D.19561;
  unsigned char D.19562;
  int D.19563;
  const unsigned char * D.19568;
  unsigned char D.19569;
  int D.19570;
  const unsigned char * D.19571;
  unsigned char D.19572;
  int D.19573;
  const unsigned char * D.19578;
  unsigned char D.19579;
  int D.19580;
  const unsigned char * D.19581;
  unsigned char D.19582;
  int D.19583;
  int D.18368;
  int iftmp.29;
  int D.18367;
  const char[27] * D.19589;
  unsigned char D.19590;
  int D.19591;
  unsigned char D.19592;
  int D.19593;
  const unsigned char * D.19598;
  unsigned char D.19599;
  int D.19600;
  const unsigned char * D.19601;
  unsigned char D.19602;
  int D.19603;
  const unsigned char * D.19608;
  unsigned char D.19609;
  int D.19610;
  const unsigned char * D.19611;
  unsigned char D.19612;
  int D.19613;
  const unsigned char * D.19618;
  unsigned char D.19619;
  int D.19620;
  const unsigned char * D.19621;
  unsigned char D.19622;
  int D.19623;

  D.19330 = method->klass;
  D.19331 = D.19330->image;
  D.19332 = mono_security_core_clr_is_platform_image (D.19331);
  if (D.19332 == 0) goto <D.19333>; else goto <D.19334>;
  <D.19333>:
  D.19335 = 0;
  return D.19335;
  <D.19334>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.19330 = method->klass;
      __s2 = D.19330->name_space;
      D.19339 = "System.Reflection";
      D.19340 = MEM[(const unsigned char *)D.19339];
      D.19341 = (int) D.19340;
      D.19342 = *__s2;
      D.19343 = (int) D.19342;
      __result = D.19341 - D.19343;
      {
        if (__s2_len != 0) goto <D.19344>; else goto <D.19345>;
        <D.19344>:
        if (__result == 0) goto <D.19346>; else goto <D.19347>;
        <D.19346>:
        D.19348 = &MEM[(void *)"System.Reflection" + 1B];
        D.19349 = *D.19348;
        D.19350 = (int) D.19349;
        D.19351 = __s2 + 1;
        D.19352 = *D.19351;
        D.19353 = (int) D.19352;
        __result = D.19350 - D.19353;
        if (__s2_len > 1) goto <D.19354>; else goto <D.19355>;
        <D.19354>:
        if (__result == 0) goto <D.19356>; else goto <D.19357>;
        <D.19356>:
        D.19358 = &MEM[(void *)"System.Reflection" + 2B];
        D.19359 = *D.19358;
        D.19360 = (int) D.19359;
        D.19361 = __s2 + 2;
        D.19362 = *D.19361;
        D.19363 = (int) D.19362;
        __result = D.19360 - D.19363;
        if (__s2_len > 2) goto <D.19364>; else goto <D.19365>;
        <D.19364>:
        if (__result == 0) goto <D.19366>; else goto <D.19367>;
        <D.19366>:
        D.19368 = &MEM[(void *)"System.Reflection" + 3B];
        D.19369 = *D.19368;
        D.19370 = (int) D.19369;
        D.19371 = __s2 + 3;
        D.19372 = *D.19371;
        D.19373 = (int) D.19372;
        __result = D.19370 - D.19373;
        <D.19367>:
        <D.19365>:
        <D.19357>:
        <D.19355>:
        <D.19347>:
        <D.19345>:
      }
      D.18313 = __result;
    }
    iftmp.23 = -D.18313;
    goto <D.19374>;
    <D.19338>:
    D.19330 = method->klass;
    D.19375 = D.19330->name_space;
    iftmp.23 = __builtin_strcmp (D.19375, "System.Reflection");
    <D.19374>:
    D.18314 = iftmp.23;
  }
  if (D.18314 != 0) goto <D.19376>; else goto <D.19377>;
  <D.19376>:
  D.19335 = 0;
  return D.19335;
  <D.19377>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.19330 = method->klass;
      __s2 = D.19330->name;
      D.19381 = "MonoProperty";
      D.19382 = MEM[(const unsigned char *)D.19381];
      D.19383 = (int) D.19382;
      D.19384 = *__s2;
      D.19385 = (int) D.19384;
      __result = D.19383 - D.19385;
      {
        if (__s2_len != 0) goto <D.19386>; else goto <D.19387>;
        <D.19386>:
        if (__result == 0) goto <D.19388>; else goto <D.19389>;
        <D.19388>:
        D.19390 = &MEM[(void *)"MonoProperty" + 1B];
        D.19391 = *D.19390;
        D.19392 = (int) D.19391;
        D.19393 = __s2 + 1;
        D.19394 = *D.19393;
        D.19395 = (int) D.19394;
        __result = D.19392 - D.19395;
        if (__s2_len > 1) goto <D.19396>; else goto <D.19397>;
        <D.19396>:
        if (__result == 0) goto <D.19398>; else goto <D.19399>;
        <D.19398>:
        D.19400 = &MEM[(void *)"MonoProperty" + 2B];
        D.19401 = *D.19400;
        D.19402 = (int) D.19401;
        D.19403 = __s2 + 2;
        D.19404 = *D.19403;
        D.19405 = (int) D.19404;
        __result = D.19402 - D.19405;
        if (__s2_len > 2) goto <D.19406>; else goto <D.19407>;
        <D.19406>:
        if (__result == 0) goto <D.19408>; else goto <D.19409>;
        <D.19408>:
        D.19410 = &MEM[(void *)"MonoProperty" + 3B];
        D.19411 = *D.19410;
        D.19412 = (int) D.19411;
        D.19413 = __s2 + 3;
        D.19414 = *D.19413;
        D.19415 = (int) D.19414;
        __result = D.19412 - D.19415;
        <D.19409>:
        <D.19407>:
        <D.19399>:
        <D.19397>:
        <D.19389>:
        <D.19387>:
      }
      D.18322 = __result;
    }
    iftmp.24 = -D.18322;
    goto <D.19416>;
    <D.19380>:
    D.19330 = method->klass;
    D.19417 = D.19330->name;
    iftmp.24 = __builtin_strcmp (D.19417, "MonoProperty");
    <D.19416>:
    D.18323 = iftmp.24;
  }
  if (D.18323 == 0) goto <D.19418>; else goto <D.19419>;
  <D.19418>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.19425 = "GetterAdapterFrame";
      D.19426 = MEM[(const unsigned char *)D.19425];
      D.19427 = (int) D.19426;
      D.19428 = *__s2;
      D.19429 = (int) D.19428;
      __result = D.19427 - D.19429;
      {
        if (__s2_len != 0) goto <D.19430>; else goto <D.19431>;
        <D.19430>:
        if (__result == 0) goto <D.19432>; else goto <D.19433>;
        <D.19432>:
        D.19434 = &MEM[(void *)"GetterAdapterFrame" + 1B];
        D.19435 = *D.19434;
        D.19436 = (int) D.19435;
        D.19437 = __s2 + 1;
        D.19438 = *D.19437;
        D.19439 = (int) D.19438;
        __result = D.19436 - D.19439;
        if (__s2_len > 1) goto <D.19440>; else goto <D.19441>;
        <D.19440>:
        if (__result == 0) goto <D.19442>; else goto <D.19443>;
        <D.19442>:
        D.19444 = &MEM[(void *)"GetterAdapterFrame" + 2B];
        D.19445 = *D.19444;
        D.19446 = (int) D.19445;
        D.19447 = __s2 + 2;
        D.19448 = *D.19447;
        D.19449 = (int) D.19448;
        __result = D.19446 - D.19449;
        if (__s2_len > 2) goto <D.19450>; else goto <D.19451>;
        <D.19450>:
        if (__result == 0) goto <D.19452>; else goto <D.19453>;
        <D.19452>:
        D.19454 = &MEM[(void *)"GetterAdapterFrame" + 3B];
        D.19455 = *D.19454;
        D.19456 = (int) D.19455;
        D.19457 = __s2 + 3;
        D.19458 = *D.19457;
        D.19459 = (int) D.19458;
        __result = D.19456 - D.19459;
        <D.19453>:
        <D.19451>:
        <D.19443>:
        <D.19441>:
        <D.19433>:
        <D.19431>:
      }
      D.18331 = __result;
    }
    iftmp.25 = -D.18331;
    goto <D.19460>;
    <D.19424>:
    D.19461 = method->name;
    iftmp.25 = __builtin_strcmp (D.19461, "GetterAdapterFrame");
    <D.19460>:
    D.18332 = iftmp.25;
  }
  if (D.18332 == 0) goto <D.19420>; else goto <D.19462>;
  <D.19462>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.19466 = "StaticGetterAdapterFrame";
      D.19467 = MEM[(const unsigned char *)D.19466];
      D.19468 = (int) D.19467;
      D.19469 = *__s2;
      D.19470 = (int) D.19469;
      __result = D.19468 - D.19470;
      {
        if (__s2_len != 0) goto <D.19471>; else goto <D.19472>;
        <D.19471>:
        if (__result == 0) goto <D.19473>; else goto <D.19474>;
        <D.19473>:
        D.19475 = &MEM[(void *)"StaticGetterAdapterFrame" + 1B];
        D.19476 = *D.19475;
        D.19477 = (int) D.19476;
        D.19478 = __s2 + 1;
        D.19479 = *D.19478;
        D.19480 = (int) D.19479;
        __result = D.19477 - D.19480;
        if (__s2_len > 1) goto <D.19481>; else goto <D.19482>;
        <D.19481>:
        if (__result == 0) goto <D.19483>; else goto <D.19484>;
        <D.19483>:
        D.19485 = &MEM[(void *)"StaticGetterAdapterFrame" + 2B];
        D.19486 = *D.19485;
        D.19487 = (int) D.19486;
        D.19488 = __s2 + 2;
        D.19489 = *D.19488;
        D.19490 = (int) D.19489;
        __result = D.19487 - D.19490;
        if (__s2_len > 2) goto <D.19491>; else goto <D.19492>;
        <D.19491>:
        if (__result == 0) goto <D.19493>; else goto <D.19494>;
        <D.19493>:
        D.19495 = &MEM[(void *)"StaticGetterAdapterFrame" + 3B];
        D.19496 = *D.19495;
        D.19497 = (int) D.19496;
        D.19498 = __s2 + 3;
        D.19499 = *D.19498;
        D.19500 = (int) D.19499;
        __result = D.19497 - D.19500;
        <D.19494>:
        <D.19492>:
        <D.19484>:
        <D.19482>:
        <D.19474>:
        <D.19472>:
      }
      D.18340 = __result;
    }
    iftmp.26 = -D.18340;
    goto <D.19501>;
    <D.19465>:
    D.19461 = method->name;
    iftmp.26 = __builtin_strcmp (D.19461, "StaticGetterAdapterFrame");
    <D.19501>:
    D.18341 = iftmp.26;
  }
  if (D.18341 == 0) goto <D.19420>; else goto <D.19421>;
  <D.19420>:
  D.19335 = 1;
  return D.19335;
  <D.19421>:
  goto <D.19502>;
  <D.19419>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.19330 = method->klass;
      __s2 = D.19330->name;
      D.19506 = "EventInfo";
      D.19507 = MEM[(const unsigned char *)D.19506];
      D.19508 = (int) D.19507;
      D.19509 = *__s2;
      D.19510 = (int) D.19509;
      __result = D.19508 - D.19510;
      {
        if (__s2_len != 0) goto <D.19511>; else goto <D.19512>;
        <D.19511>:
        if (__result == 0) goto <D.19513>; else goto <D.19514>;
        <D.19513>:
        D.19515 = &MEM[(void *)"EventInfo" + 1B];
        D.19516 = *D.19515;
        D.19517 = (int) D.19516;
        D.19518 = __s2 + 1;
        D.19519 = *D.19518;
        D.19520 = (int) D.19519;
        __result = D.19517 - D.19520;
        if (__s2_len > 1) goto <D.19521>; else goto <D.19522>;
        <D.19521>:
        if (__result == 0) goto <D.19523>; else goto <D.19524>;
        <D.19523>:
        D.19525 = &MEM[(void *)"EventInfo" + 2B];
        D.19526 = *D.19525;
        D.19527 = (int) D.19526;
        D.19528 = __s2 + 2;
        D.19529 = *D.19528;
        D.19530 = (int) D.19529;
        __result = D.19527 - D.19530;
        if (__s2_len > 2) goto <D.19531>; else goto <D.19532>;
        <D.19531>:
        if (__result == 0) goto <D.19533>; else goto <D.19534>;
        <D.19533>:
        D.19535 = &MEM[(void *)"EventInfo" + 3B];
        D.19536 = *D.19535;
        D.19537 = (int) D.19536;
        D.19538 = __s2 + 3;
        D.19539 = *D.19538;
        D.19540 = (int) D.19539;
        __result = D.19537 - D.19540;
        <D.19534>:
        <D.19532>:
        <D.19524>:
        <D.19522>:
        <D.19514>:
        <D.19512>:
      }
      D.18349 = __result;
    }
    iftmp.27 = -D.18349;
    goto <D.19541>;
    <D.19505>:
    D.19330 = method->klass;
    D.19417 = D.19330->name;
    iftmp.27 = __builtin_strcmp (D.19417, "EventInfo");
    <D.19541>:
    D.18350 = iftmp.27;
  }
  if (D.18350 == 0) goto <D.19542>; else goto <D.19543>;
  <D.19542>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.19549 = "AddEventFrame";
      D.19550 = MEM[(const unsigned char *)D.19549];
      D.19551 = (int) D.19550;
      D.19552 = *__s2;
      D.19553 = (int) D.19552;
      __result = D.19551 - D.19553;
      {
        if (__s2_len != 0) goto <D.19554>; else goto <D.19555>;
        <D.19554>:
        if (__result == 0) goto <D.19556>; else goto <D.19557>;
        <D.19556>:
        D.19558 = &MEM[(void *)"AddEventFrame" + 1B];
        D.19559 = *D.19558;
        D.19560 = (int) D.19559;
        D.19561 = __s2 + 1;
        D.19562 = *D.19561;
        D.19563 = (int) D.19562;
        __result = D.19560 - D.19563;
        if (__s2_len > 1) goto <D.19564>; else goto <D.19565>;
        <D.19564>:
        if (__result == 0) goto <D.19566>; else goto <D.19567>;
        <D.19566>:
        D.19568 = &MEM[(void *)"AddEventFrame" + 2B];
        D.19569 = *D.19568;
        D.19570 = (int) D.19569;
        D.19571 = __s2 + 2;
        D.19572 = *D.19571;
        D.19573 = (int) D.19572;
        __result = D.19570 - D.19573;
        if (__s2_len > 2) goto <D.19574>; else goto <D.19575>;
        <D.19574>:
        if (__result == 0) goto <D.19576>; else goto <D.19577>;
        <D.19576>:
        D.19578 = &MEM[(void *)"AddEventFrame" + 3B];
        D.19579 = *D.19578;
        D.19580 = (int) D.19579;
        D.19581 = __s2 + 3;
        D.19582 = *D.19581;
        D.19583 = (int) D.19582;
        __result = D.19580 - D.19583;
        <D.19577>:
        <D.19575>:
        <D.19567>:
        <D.19565>:
        <D.19557>:
        <D.19555>:
      }
      D.18358 = __result;
    }
    iftmp.28 = -D.18358;
    goto <D.19584>;
    <D.19548>:
    D.19461 = method->name;
    iftmp.28 = __builtin_strcmp (D.19461, "AddEventFrame");
    <D.19584>:
    D.18359 = iftmp.28;
  }
  if (D.18359 == 0) goto <D.19544>; else goto <D.19585>;
  <D.19585>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.19589 = "StaticAddEventAdapterFrame";
      D.19590 = MEM[(const unsigned char *)D.19589];
      D.19591 = (int) D.19590;
      D.19592 = *__s2;
      D.19593 = (int) D.19592;
      __result = D.19591 - D.19593;
      {
        if (__s2_len != 0) goto <D.19594>; else goto <D.19595>;
        <D.19594>:
        if (__result == 0) goto <D.19596>; else goto <D.19597>;
        <D.19596>:
        D.19598 = &MEM[(void *)"StaticAddEventAdapterFrame" + 1B];
        D.19599 = *D.19598;
        D.19600 = (int) D.19599;
        D.19601 = __s2 + 1;
        D.19602 = *D.19601;
        D.19603 = (int) D.19602;
        __result = D.19600 - D.19603;
        if (__s2_len > 1) goto <D.19604>; else goto <D.19605>;
        <D.19604>:
        if (__result == 0) goto <D.19606>; else goto <D.19607>;
        <D.19606>:
        D.19608 = &MEM[(void *)"StaticAddEventAdapterFrame" + 2B];
        D.19609 = *D.19608;
        D.19610 = (int) D.19609;
        D.19611 = __s2 + 2;
        D.19612 = *D.19611;
        D.19613 = (int) D.19612;
        __result = D.19610 - D.19613;
        if (__s2_len > 2) goto <D.19614>; else goto <D.19615>;
        <D.19614>:
        if (__result == 0) goto <D.19616>; else goto <D.19617>;
        <D.19616>:
        D.19618 = &MEM[(void *)"StaticAddEventAdapterFrame" + 3B];
        D.19619 = *D.19618;
        D.19620 = (int) D.19619;
        D.19621 = __s2 + 3;
        D.19622 = *D.19621;
        D.19623 = (int) D.19622;
        __result = D.19620 - D.19623;
        <D.19617>:
        <D.19615>:
        <D.19607>:
        <D.19605>:
        <D.19597>:
        <D.19595>:
      }
      D.18367 = __result;
    }
    iftmp.29 = -D.18367;
    goto <D.19624>;
    <D.19588>:
    D.19461 = method->name;
    iftmp.29 = __builtin_strcmp (D.19461, "StaticAddEventAdapterFrame");
    <D.19624>:
    D.18368 = iftmp.29;
  }
  if (D.18368 == 0) goto <D.19544>; else goto <D.19545>;
  <D.19544>:
  D.19335 = 1;
  return D.19335;
  <D.19545>:
  <D.19543>:
  <D.19502>:
  D.19335 = 0;
  return D.19335;
}


get_argument_exception (const char * format, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoException * D.19626;
  struct MonoException * ex;
  char * caller_name;
  char * callee_name;
  char * message;

  caller_name = get_method_full_name (caller);
  callee_name = get_method_full_name (callee);
  message = monoeg_g_strdup_printf (format, caller_name, callee_name);
  monoeg_g_free (callee_name);
  monoeg_g_free (caller_name);
  mono_trace (16, 64, message);
  ex = mono_get_exception_argument ("method", message);
  monoeg_g_free (message);
  D.19626 = ex;
  return D.19626;
}


mono_security_core_clr_ensure_dynamic_method_resolved_object (void * ref, struct MonoClass * handle_class)
{
  struct MonoClass * D.19628;
  struct MonoImage * D.19631;
  int D.19632;
  int D.19635;
  struct MonoException * D.19638;
  struct MonoClass * D.19640;
  struct MonoClass * D.19643;
  struct MonoImage * D.19644;
  int D.19645;
  int D.19648;

  D.19628 = mono_defaults.fieldhandle_class;
  if (D.19628 == handle_class) goto <D.19629>; else goto <D.19630>;
  <D.19629>:
  {
    struct MonoClassField * field;
    struct MonoClass * klass;

    field = ref;
    klass = mono_field_get_parent (field);
    D.19631 = klass->image;
    D.19632 = mono_security_core_clr_is_platform_image (D.19631);
    if (D.19632 != 0) goto <D.19633>; else goto <D.19634>;
    <D.19633>:
    {
      struct MonoMethod * caller;

      caller = get_reflection_caller ();
      D.19635 = check_field_access (caller, field);
      if (D.19635 == 0) goto <D.19636>; else goto <D.19637>;
      <D.19636>:
      D.19638 = get_field_access_exception ("Dynamic method %s cannot create access private/internal field %s.", caller, field);
      return D.19638;
      <D.19637>:
    }
    <D.19634>:
  }
  goto <D.19639>;
  <D.19630>:
  D.19640 = mono_defaults.methodhandle_class;
  if (D.19640 == handle_class) goto <D.19641>; else goto <D.19642>;
  <D.19641>:
  {
    struct MonoMethod * method;

    method = ref;
    D.19643 = method->klass;
    D.19644 = D.19643->image;
    D.19645 = mono_security_core_clr_is_platform_image (D.19644);
    if (D.19645 != 0) goto <D.19646>; else goto <D.19647>;
    <D.19646>:
    {
      struct MonoMethod * caller;

      caller = get_reflection_caller ();
      D.19648 = check_method_access (caller, method);
      if (D.19648 == 0) goto <D.19649>; else goto <D.19650>;
      <D.19649>:
      D.19638 = get_method_access_exception ("Dynamic method %s cannot create access private/internal method %s.", caller, method);
      return D.19638;
      <D.19650>:
    }
    <D.19647>:
  }
  <D.19642>:
  <D.19639>:
  D.19638 = 0B;
  return D.19638;
}


mono_security_core_clr_can_access_internals (struct MonoImage * accessing, struct MonoImage * accessed)
{
  int D.19652;
  gboolean D.19655;
  int D.19656;
  struct MonoAssembly * D.19661;
  char * D.19662;
  struct MonoAssembly * D.19664;
  char * D.19665;
  int D.18395;
  _Bool D.19666;

  D.19652 = mono_security_core_clr_is_platform_image (accessed);
  if (D.19652 == 0) goto <D.19653>; else goto <D.19654>;
  <D.19653>:
  D.19655 = 1;
  return D.19655;
  <D.19654>:
  D.19656 = mono_security_core_clr_is_platform_image (accessing);
  if (D.19656 != 0) goto <D.19657>; else goto <D.19658>;
  <D.19657>:
  D.19655 = 1;
  return D.19655;
  <D.19658>:
  D.19661 = accessed->assembly;
  D.19662 = D.19661->basedir;
  if (D.19662 == 0B) goto <D.19659>; else goto <D.19663>;
  <D.19663>:
  D.19664 = accessing->assembly;
  D.19665 = D.19664->basedir;
  if (D.19665 == 0B) goto <D.19659>; else goto <D.19660>;
  <D.19659>:
  D.19655 = 0;
  return D.19655;
  <D.19660>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19661 = accessed->assembly;
    D.19662 = D.19661->basedir;
    D.19664 = accessing->assembly;
    D.19665 = D.19664->basedir;
    D.18395 = __builtin_strcmp (D.19662, D.19665);
  }
  D.19666 = D.18395 == 0;
  D.19655 = (gboolean) D.19666;
  return D.19655;
}


mono_security_core_clr_is_field_access_allowed (struct MonoMethod * caller, struct MonoClassField * field)
{
  struct MonoClass * D.19668;
  <unnamed type> D.19669;
  struct MonoException * D.19672;
  <unnamed type> D.19676;

  D.19668 = mono_field_get_parent (field);
  D.19669 = mono_security_core_clr_class_level (D.19668);
  if (D.19669 != 2) goto <D.19670>; else goto <D.19671>;
  <D.19670>:
  D.19672 = 0B;
  return D.19672;
  <D.19671>:
  if (caller == 0B) goto <D.19673>; else goto <D.19675>;
  <D.19675>:
  D.19676 = mono_security_core_clr_method_level (caller, 1);
  if (D.19676 != 0) goto <D.19673>; else goto <D.19674>;
  <D.19673>:
  D.19672 = 0B;
  return D.19672;
  <D.19674>:
  D.19672 = get_field_access_exception ("Transparent method %s cannot call use Critical field %s.", caller, field);
  return D.19672;
}


mono_security_core_clr_is_call_allowed (struct MonoMethod * caller, struct MonoMethod * callee)
{
  <unnamed type> D.19678;
  struct MonoException * D.19681;
  <unnamed type> D.19685;

  D.19678 = mono_security_core_clr_method_level (callee, 1);
  if (D.19678 != 2) goto <D.19679>; else goto <D.19680>;
  <D.19679>:
  D.19681 = 0B;
  return D.19681;
  <D.19680>:
  if (caller == 0B) goto <D.19682>; else goto <D.19684>;
  <D.19684>:
  D.19685 = mono_security_core_clr_method_level (caller, 1);
  if (D.19685 != 0) goto <D.19682>; else goto <D.19683>;
  <D.19682>:
  D.19681 = 0B;
  return D.19681;
  <D.19683>:
  D.19681 = get_method_access_exception ("Transparent method %s cannot call Critical method %s.", caller, callee);
  return D.19681;
}


mono_security_core_clr_class_level (struct MonoClass * class)
{
  int mono_security_core_clr_test.30;
  struct MonoImage * D.19690;
  int D.19691;
  MonoSecurityCoreCLRLevel D.19694;

  mono_security_core_clr_test.30 = mono_security_core_clr_test;
  if (mono_security_core_clr_test.30 == 0) goto <D.19688>; else goto <D.19689>;
  <D.19688>:
  D.19690 = class->image;
  D.19691 = mono_security_core_clr_is_platform_image (D.19690);
  if (D.19691 == 0) goto <D.19692>; else goto <D.19693>;
  <D.19692>:
  D.19694 = 0;
  return D.19694;
  <D.19693>:
  <D.19689>:
  D.19694 = mono_security_core_clr_class_level_no_platform_check (class);
  return D.19694;
}


mono_security_core_clr_class_level_no_platform_check (struct MonoClass * class)
{
  struct MonoImage * D.19698;
  struct MonoClass * D.19701;
  MonoSecurityCoreCLRLevel D.19704;
  MonoSecurityCoreCLRLevel level;
  struct MonoCustomAttrInfo * cinfo;

  level = 0;
  cinfo = mono_custom_attrs_from_class (class);
  if (cinfo != 0B) goto <D.19696>; else goto <D.19697>;
  <D.19696>:
  D.19698 = class->image;
  level = mono_security_core_clr_level_from_cinfo (cinfo, D.19698);
  mono_custom_attrs_free (cinfo);
  <D.19697>:
  if (level == 0) goto <D.19699>; else goto <D.19700>;
  <D.19699>:
  D.19701 = class->nested_in;
  if (D.19701 != 0B) goto <D.19702>; else goto <D.19703>;
  <D.19702>:
  D.19701 = class->nested_in;
  level = mono_security_core_clr_class_level_no_platform_check (D.19701);
  <D.19703>:
  <D.19700>:
  D.19704 = level;
  return D.19704;
}


mono_security_core_clr_level_from_cinfo (struct MonoCustomAttrInfo * cinfo, struct MonoImage * image)
{
  struct MonoClass * D.19708;
  int D.19709;
  struct MonoClass * D.19714;
  int D.19715;
  MonoSecurityCoreCLRLevel D.19718;
  int level;

  level = 0;
  if (cinfo != 0B) goto <D.19706>; else goto <D.19707>;
  <D.19706>:
  D.19708 = security_safe_critical_attribute ();
  D.19709 = mono_custom_attrs_has_attr (cinfo, D.19708);
  if (D.19709 != 0) goto <D.19710>; else goto <D.19711>;
  <D.19710>:
  level = 1;
  <D.19711>:
  <D.19707>:
  if (cinfo != 0B) goto <D.19712>; else goto <D.19713>;
  <D.19712>:
  D.19714 = security_critical_attribute ();
  D.19715 = mono_custom_attrs_has_attr (cinfo, D.19714);
  if (D.19715 != 0) goto <D.19716>; else goto <D.19717>;
  <D.19716>:
  level = 2;
  <D.19717>:
  <D.19713>:
  D.19718 = (MonoSecurityCoreCLRLevel) level;
  return D.19718;
}


security_safe_critical_attribute ()
{
  struct MonoClass * class.31;
  struct MonoImage * D.19723;
  struct MonoClass * class.32;
  _Bool D.19725;
  long int D.19726;
  long int D.19727;
  struct MonoClass * D.19730;
  static struct MonoClass * class = 0B;

  class.31 = class;
  if (class.31 == 0B) goto <D.19721>; else goto <D.19722>;
  <D.19721>:
  D.19723 = mono_defaults.corlib;
  class.32 = mono_class_from_name (D.19723, "System.Security", "SecuritySafeCriticalAttribute");
  class = class.32;
  <D.19722>:
  class.31 = class;
  D.19725 = class.31 == 0B;
  D.19726 = (long int) D.19725;
  D.19727 = __builtin_expect (D.19726, 0);
  if (D.19727 != 0) goto <D.19728>; else goto <D.19729>;
  <D.19728>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-core-clr.c", 147, "class");
  <D.19729>:
  D.19730 = class;
  return D.19730;
}


security_critical_attribute ()
{
  struct MonoClass * class.33;
  struct MonoImage * D.19735;
  struct MonoClass * class.34;
  _Bool D.19737;
  long int D.19738;
  long int D.19739;
  struct MonoClass * D.19742;
  static struct MonoClass * class = 0B;

  class.33 = class;
  if (class.33 == 0B) goto <D.19733>; else goto <D.19734>;
  <D.19733>:
  D.19735 = mono_defaults.corlib;
  class.34 = mono_class_from_name (D.19735, "System.Security", "SecurityCriticalAttribute");
  class = class.34;
  <D.19734>:
  class.33 = class;
  D.19737 = class.33 == 0B;
  D.19738 = (long int) D.19737;
  D.19739 = __builtin_expect (D.19738, 0);
  if (D.19739 != 0) goto <D.19740>; else goto <D.19741>;
  <D.19740>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-core-clr.c", 134, "class");
  <D.19741>:
  D.19742 = class;
  return D.19742;
}


mono_security_core_clr_method_level (struct MonoMethod * method, gboolean with_class_level)
{
  MonoSecurityCoreCLRLevel D.19746;
  int mono_security_core_clr_test.35;
  struct MonoClass * D.19750;
  struct MonoImage * D.19751;
  int D.19752;
  struct MonoCustomAttrInfo * cinfo;
  MonoSecurityCoreCLRLevel level;

  level = 0;
  if (method == 0B) goto <D.19744>; else goto <D.19745>;
  <D.19744>:
  D.19746 = level;
  return D.19746;
  <D.19745>:
  mono_security_core_clr_test.35 = mono_security_core_clr_test;
  if (mono_security_core_clr_test.35 == 0) goto <D.19748>; else goto <D.19749>;
  <D.19748>:
  D.19750 = method->klass;
  D.19751 = D.19750->image;
  D.19752 = mono_security_core_clr_is_platform_image (D.19751);
  if (D.19752 == 0) goto <D.19753>; else goto <D.19754>;
  <D.19753>:
  D.19746 = level;
  return D.19746;
  <D.19754>:
  <D.19749>:
  cinfo = mono_custom_attrs_from_method (method);
  if (cinfo != 0B) goto <D.19755>; else goto <D.19756>;
  <D.19755>:
  D.19750 = method->klass;
  D.19751 = D.19750->image;
  level = mono_security_core_clr_level_from_cinfo (cinfo, D.19751);
  mono_custom_attrs_free (cinfo);
  <D.19756>:
  if (with_class_level != 0) goto <D.19757>; else goto <D.19758>;
  <D.19757>:
  if (level == 0) goto <D.19759>; else goto <D.19760>;
  <D.19759>:
  D.19750 = method->klass;
  level = mono_security_core_clr_class_level (D.19750);
  <D.19760>:
  <D.19758>:
  D.19746 = level;
  return D.19746;
}


mono_security_enable_core_clr ()
{
  mono_verifier_set_mode (2);
  mono_security_set_mode (1);
}