mono_security_core_clr_set_options (MonoSecurityCoreCLROptions options)
{
  security_core_clr_options = options;
}


mono_security_core_clr_get_options ()
{
  MonoSecurityCoreCLROptions D.20083;

  D.20083 = security_core_clr_options;
  return D.20083;
}


mono_security_core_clr_determine_platform_image (struct MonoImage * image)
{
  gboolean D.20085;
  mono_bool (*<T15cc>) (const char *) platform_callback.0;
  char * D.20087;

  platform_callback.0 = platform_callback;
  D.20087 = image->name;
  D.20085 = platform_callback.0 (D.20087);
  return D.20085;
}


default_platform_check (const char * image_name)
{
  struct MonoImage * D.20089;
  gboolean D.20092;
  int D.19670;
  char * D.20093;
  _Bool D.20094;
  unsigned int D.20095;
  unsigned int D.20096;
  int iftmp.1;
  int D.19682;
  int iftmp.2;
  int D.19678;
  sizetype ilen.3;
  sizetype clen.4;
  sizetype D.20106;
  const char[13] * D.20107;
  unsigned char D.20108;
  int D.20109;
  unsigned char D.20110;
  int D.20111;
  _Bool D.20112;
  _Bool D.20113;
  _Bool D.20114;
  const unsigned char * D.20117;
  unsigned char D.20118;
  int D.20119;
  const unsigned char * D.20120;
  unsigned char D.20121;
  int D.20122;
  _Bool D.20123;
  _Bool D.20124;
  const unsigned char * D.20127;
  unsigned char D.20128;
  int D.20129;
  const unsigned char * D.20130;
  unsigned char D.20131;
  int D.20132;
  _Bool D.20133;
  _Bool D.20134;
  const unsigned char * D.20137;
  unsigned char D.20138;
  int D.20139;
  const unsigned char * D.20140;
  unsigned char D.20141;
  int D.20142;
  const char * D.20144;

  D.20089 = mono_defaults.corlib;
  if (D.20089 != 0B) goto <D.20090>; else goto <D.20091>;
  <D.20090>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20089 = mono_defaults.corlib;
    D.20093 = D.20089->name;
    D.19670 = __builtin_strcmp (D.20093, image_name);
  }
  D.20094 = D.19670 == 0;
  D.20092 = (gboolean) D.20094;
  return D.20092;
  <D.20091>:
  {
    const char * corlib;
    int ilen;
    int clen;

    corlib = "mscorlib.dll";
    D.20095 = strlen (image_name);
    ilen = (int) D.20095;
    D.20096 = strlen (corlib);
    clen = (int) D.20096;
    if (ilen >= clen) goto <D.20100>; else goto <D.20098>;
    <D.20100>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        ilen.3 = (sizetype) ilen;
        clen.4 = (sizetype) clen;
        D.20106 = ilen.3 - clen.4;
        __s2 = image_name + D.20106;
        D.20107 = "mscorlib.dll";
        D.20108 = MEM[(const unsigned char *)D.20107];
        D.20109 = (int) D.20108;
        D.20110 = *__s2;
        D.20111 = (int) D.20110;
        __result = D.20109 - D.20111;
        {
          D.20112 = __s1_len != 0;
          D.20113 = __result == 0;
          D.20114 = D.20112 & D.20113;
          if (D.20114 != 0) goto <D.20115>; else goto <D.20116>;
          <D.20115>:
          D.20117 = &MEM[(void *)"mscorlib.dll" + 1B];
          D.20118 = *D.20117;
          D.20119 = (int) D.20118;
          D.20120 = __s2 + 1;
          D.20121 = *D.20120;
          D.20122 = (int) D.20121;
          __result = D.20119 - D.20122;
          D.20123 = __s1_len > 1;
          D.20113 = __result == 0;
          D.20124 = D.20123 & D.20113;
          if (D.20124 != 0) goto <D.20125>; else goto <D.20126>;
          <D.20125>:
          D.20127 = &MEM[(void *)"mscorlib.dll" + 2B];
          D.20128 = *D.20127;
          D.20129 = (int) D.20128;
          D.20130 = __s2 + 2;
          D.20131 = *D.20130;
          D.20132 = (int) D.20131;
          __result = D.20129 - D.20132;
          D.20133 = __s1_len > 2;
          D.20113 = __result == 0;
          D.20134 = D.20133 & D.20113;
          if (D.20134 != 0) goto <D.20135>; else goto <D.20136>;
          <D.20135>:
          D.20137 = &MEM[(void *)"mscorlib.dll" + 3B];
          D.20138 = *D.20137;
          D.20139 = (int) D.20138;
          D.20140 = __s2 + 3;
          D.20141 = *D.20140;
          D.20142 = (int) D.20141;
          __result = D.20139 - D.20142;
          <D.20136>:
          <D.20126>:
          <D.20116>:
        }
        D.19678 = __result;
      }
      iftmp.2 = D.19678;
      goto <D.20143>;
      <D.20103>:
      ilen.3 = (sizetype) ilen;
      clen.4 = (sizetype) clen;
      D.20106 = ilen.3 - clen.4;
      D.20144 = image_name + D.20106;
      iftmp.2 = __builtin_strcmp ("mscorlib.dll", D.20144);
      <D.20143>:
      D.19682 = iftmp.2;
    }
    if (D.19682 == 0) goto <D.20145>; else goto <D.20098>;
    <D.20145>:
    iftmp.1 = 1;
    goto <D.20099>;
    <D.20098>:
    iftmp.1 = 0;
    <D.20099>:
    D.20092 = iftmp.1;
    return D.20092;
  }
}


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.20147;
  <unnamed-unsigned:1> D.20148;

  D.20148 = image->core_clr_platform_code;
  D.20147 = (gboolean) D.20148;
  return D.20147;
}


mono_security_core_clr_check_inheritance (struct MonoClass * class)
{
  short unsigned int D.20157;
  int D.20158;
  int D.20159;
  struct MonoMethod * D.20162;
  MonoSecurityCoreCLRLevel class_level;
  MonoSecurityCoreCLRLevel parent_level;
  struct MonoClass * parent;

  parent = class->parent;
  if (parent == 0B) goto <D.20150>; else goto <D.20151>;
  <D.20150>:
  return;
  <D.20151>:
  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.20152>; else goto <D.20153>;
  <D.20152>:
  set_type_load_exception_type ("Inheritance failure for type %s. Parent class %s is more restricted.", class);
  goto <D.20154>;
  <D.20153>:
  {
    struct MonoMethod * parent_ctor;

    parent_ctor = get_default_ctor (parent);
    if (parent_ctor != 0B) goto <D.20155>; else goto <D.20156>;
    <D.20155>:
    D.20157 = parent_ctor->flags;
    D.20158 = (int) D.20157;
    D.20159 = D.20158 & 6;
    if (D.20159 != 0) goto <D.20160>; else goto <D.20161>;
    <D.20160>:
    D.20162 = get_default_ctor (class);
    class_level = mono_security_core_clr_method_level (D.20162, 0);
    parent_level = mono_security_core_clr_method_level (parent_ctor, 0);
    if (class_level < parent_level) goto <D.20163>; else goto <D.20164>;
    <D.20163>:
    set_type_load_exception_type ("Inheritance failure for type %s. Default constructor security mismatch with %s.", class);
    <D.20164>:
    <D.20161>:
    <D.20156>:
  }
  <D.20154>:
}


get_default_ctor (struct MonoClass * klass)
{
  struct MonoMethod * * D.20166;
  struct MonoMethod * D.20169;
  unsigned int i.5;
  unsigned int D.20171;
  struct MonoMethod * * D.20172;
  short unsigned int D.20175;
  int D.20176;
  int D.20177;
  const char * D.20182;
  char D.20183;
  int D.19734;
  int iftmp.6;
  int D.19730;
  const char[6] * D.20188;
  unsigned char D.20189;
  int D.20190;
  unsigned char D.20191;
  int D.20192;
  _Bool D.20193;
  _Bool D.20194;
  _Bool D.20195;
  const unsigned char * D.20198;
  unsigned char D.20199;
  int D.20200;
  const unsigned char * D.20201;
  unsigned char D.20202;
  int D.20203;
  _Bool D.20204;
  _Bool D.20205;
  const unsigned char * D.20208;
  unsigned char D.20209;
  int D.20210;
  const unsigned char * D.20211;
  unsigned char D.20212;
  int D.20213;
  _Bool D.20214;
  _Bool D.20215;
  const unsigned char * D.20218;
  unsigned char D.20219;
  int D.20220;
  const unsigned char * D.20221;
  unsigned char D.20222;
  int D.20223;
  short unsigned int D.20227;
  unsigned int i.7;
  unsigned int D.20231;
  int i;

  mono_class_setup_methods (klass);
  D.20166 = klass->methods;
  if (D.20166 == 0B) goto <D.20167>; else goto <D.20168>;
  <D.20167>:
  D.20169 = 0B;
  return D.20169;
  <D.20168>:
  i = 0;
  goto <D.19736>;
  <D.19735>:
  {
    struct MonoMethodSignature * sig;
    struct MonoMethod * method;

    D.20166 = klass->methods;
    i.5 = (unsigned int) i;
    D.20171 = i.5 * 4;
    D.20172 = D.20166 + D.20171;
    method = *D.20172;
    if (method == 0B) goto <D.20173>; else goto <D.20174>;
    <D.20173>:
    // predicted unlikely by continue predictor.
    goto <D.19725>;
    <D.20174>:
    D.20175 = method->flags;
    D.20176 = (int) D.20175;
    D.20177 = D.20176 & 2048;
    if (D.20177 == 0) goto <D.20178>; else goto <D.20179>;
    <D.20178>:
    // predicted unlikely by continue predictor.
    goto <D.19725>;
    <D.20179>:
    D.20182 = method->name;
    D.20183 = *D.20182;
    if (D.20183 != 46) goto <D.20180>; else goto <D.20184>;
    <D.20184>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.20188 = ".ctor";
        D.20189 = MEM[(const unsigned char *)D.20188];
        D.20190 = (int) D.20189;
        D.20191 = *__s2;
        D.20192 = (int) D.20191;
        __result = D.20190 - D.20192;
        {
          D.20193 = __s1_len != 0;
          D.20194 = __result == 0;
          D.20195 = D.20193 & D.20194;
          if (D.20195 != 0) goto <D.20196>; else goto <D.20197>;
          <D.20196>:
          D.20198 = &MEM[(void *)".ctor" + 1B];
          D.20199 = *D.20198;
          D.20200 = (int) D.20199;
          D.20201 = __s2 + 1;
          D.20202 = *D.20201;
          D.20203 = (int) D.20202;
          __result = D.20200 - D.20203;
          D.20204 = __s1_len > 1;
          D.20194 = __result == 0;
          D.20205 = D.20204 & D.20194;
          if (D.20205 != 0) goto <D.20206>; else goto <D.20207>;
          <D.20206>:
          D.20208 = &MEM[(void *)".ctor" + 2B];
          D.20209 = *D.20208;
          D.20210 = (int) D.20209;
          D.20211 = __s2 + 2;
          D.20212 = *D.20211;
          D.20213 = (int) D.20212;
          __result = D.20210 - D.20213;
          D.20214 = __s1_len > 2;
          D.20194 = __result == 0;
          D.20215 = D.20214 & D.20194;
          if (D.20215 != 0) goto <D.20216>; else goto <D.20217>;
          <D.20216>:
          D.20218 = &MEM[(void *)".ctor" + 3B];
          D.20219 = *D.20218;
          D.20220 = (int) D.20219;
          D.20221 = __s2 + 3;
          D.20222 = *D.20221;
          D.20223 = (int) D.20222;
          __result = D.20220 - D.20223;
          <D.20217>:
          <D.20207>:
          <D.20197>:
        }
        D.19730 = __result;
      }
      iftmp.6 = D.19730;
      goto <D.20224>;
      <D.20187>:
      D.20182 = method->name;
      iftmp.6 = __builtin_strcmp (".ctor", D.20182);
      <D.20224>:
      D.19734 = iftmp.6;
    }
    if (D.19734 != 0) goto <D.20180>; else goto <D.20181>;
    <D.20180>:
    // predicted unlikely by continue predictor.
    goto <D.19725>;
    <D.20181>:
    sig = mono_method_signature (method);
    if (sig != 0B) goto <D.20225>; else goto <D.20226>;
    <D.20225>:
    D.20227 = sig->param_count;
    if (D.20227 == 0) goto <D.20228>; else goto <D.20229>;
    <D.20228>:
    D.20169 = method;
    return D.20169;
    <D.20229>:
    <D.20226>:
  }
  <D.19725>:
  i = i + 1;
  <D.19736>:
  i.7 = (unsigned int) i;
  D.20231 = klass->method.count;
  if (i.7 < D.20231) goto <D.19735>; else goto <D.19737>;
  <D.19737>:
  D.20169 = 0B;
  return D.20169;
}


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

  type_name = mono_type_get_full_name (class);
  D.20233 = class->parent;
  parent_name = mono_type_get_full_name (D.20233);
  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.20234>; else goto <D.20235>;
  <D.20234>:
  if (override_level != 2) goto <D.20236>; else goto <D.20237>;
  <D.20236>:
  set_type_load_exception_methods ("Override failure for %s over %s. Override MUST be [SecurityCritical].", override, base);
  <D.20237>:
  goto <D.20238>;
  <D.20235>:
  if (override_level == 2) goto <D.20239>; else goto <D.20240>;
  <D.20239>:
  set_type_load_exception_methods ("Override failure for %s over %s. Override must NOT be [SecurityCritical].", override, base);
  <D.20240>:
  <D.20238>:
}


set_type_load_exception_methods (const char * format, struct MonoMethod * override, struct MonoMethod * base)
{
  struct MonoClass * D.20241;
  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.20241 = override->klass;
  mono_class_set_failure (D.20241, 7, message);
}


get_method_full_name (struct MonoMethod * method)
{
  char * D.20242;
  char * iftmp.8;

  if (method != 0B) goto <D.20244>; else goto <D.20245>;
  <D.20244>:
  iftmp.8 = mono_method_full_name (method, 1);
  goto <D.20246>;
  <D.20245>:
  iftmp.8 = monoeg_strdup ("\'no caller found\'");
  <D.20246>:
  D.20242 = iftmp.8;
  return D.20242;
}


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

  if (str != 0B) goto <D.20248>; else goto <D.20249>;
  <D.20248>:
  D.20250 = __strdup (str);
  return D.20250;
  <D.20249>:
  D.20250 = 0B;
  return D.20250;
}


mono_security_core_clr_require_elevated_permissions ()
{
  struct MonoMethod * D.20254;
  int D.20256;
  gboolean D.20257;
  <unnamed type> D.20258;
  _Bool D.20259;
  struct ElevatedTrustCookie cookie;

  try
    {
      cookie.depth = 0;
      cookie.caller = 0B;
      mono_stack_walk_no_il (get_caller_of_elevated_trust_code, &cookie);
      D.20254 = cookie.caller;
      if (D.20254 == 0B) goto <D.20252>; else goto <D.20255>;
      <D.20255>:
      D.20256 = cookie.depth;
      if (D.20256 <= 2) goto <D.20252>; else goto <D.20253>;
      <D.20252>:
      D.20257 = 1;
      return D.20257;
      <D.20253>:
      D.20254 = cookie.caller;
      D.20258 = mono_security_core_clr_method_level (D.20254, 1);
      D.20259 = D.20258 == 0;
      D.20257 = (gboolean) D.20259;
      return D.20257;
    }
  finally
    {
      cookie = {CLOBBER};
    }
}


get_caller_of_elevated_trust_code (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  unsigned char D.20265;
  unsigned char D.20266;
  gboolean D.20267;
  struct MonoClass * D.20268;
  struct MonoImage * D.20269;
  int D.20270;
  int D.20273;
  int D.19877;
  int iftmp.9;
  int D.19876;
  const char[16] * D.20277;
  unsigned char D.20278;
  int D.20279;
  unsigned char D.20280;
  int D.20281;
  _Bool D.20282;
  _Bool D.20283;
  _Bool D.20284;
  const unsigned char * D.20287;
  unsigned char D.20288;
  int D.20289;
  const unsigned char * D.20290;
  unsigned char D.20291;
  int D.20292;
  _Bool D.20293;
  _Bool D.20294;
  const unsigned char * D.20297;
  unsigned char D.20298;
  int D.20299;
  const unsigned char * D.20300;
  unsigned char D.20301;
  int D.20302;
  _Bool D.20303;
  _Bool D.20304;
  const unsigned char * D.20307;
  unsigned char D.20308;
  int D.20309;
  const unsigned char * D.20310;
  unsigned char D.20311;
  int D.20312;
  const char * D.20314;
  int D.19886;
  int iftmp.10;
  int D.19885;
  const char[16] * D.20320;
  unsigned char D.20321;
  int D.20322;
  unsigned char D.20323;
  int D.20324;
  _Bool D.20325;
  _Bool D.20326;
  _Bool D.20327;
  const unsigned char * D.20330;
  unsigned char D.20331;
  int D.20332;
  const unsigned char * D.20333;
  unsigned char D.20334;
  int D.20335;
  _Bool D.20336;
  _Bool D.20337;
  const unsigned char * D.20340;
  unsigned char D.20341;
  int D.20342;
  const unsigned char * D.20343;
  unsigned char D.20344;
  int D.20345;
  _Bool D.20346;
  _Bool D.20347;
  const unsigned char * D.20350;
  unsigned char D.20351;
  int D.20352;
  const unsigned char * D.20353;
  unsigned char D.20354;
  int D.20355;
  const char * D.20357;
  int D.19895;
  int iftmp.11;
  int D.19894;
  const char[26] * D.20363;
  unsigned char D.20364;
  int D.20365;
  unsigned char D.20366;
  int D.20367;
  _Bool D.20368;
  _Bool D.20369;
  _Bool D.20370;
  const unsigned char * D.20373;
  unsigned char D.20374;
  int D.20375;
  const unsigned char * D.20376;
  unsigned char D.20377;
  int D.20378;
  _Bool D.20379;
  _Bool D.20380;
  const unsigned char * D.20383;
  unsigned char D.20384;
  int D.20385;
  const unsigned char * D.20386;
  unsigned char D.20387;
  int D.20388;
  _Bool D.20389;
  _Bool D.20390;
  const unsigned char * D.20393;
  unsigned char D.20394;
  int D.20395;
  const unsigned char * D.20396;
  unsigned char D.20397;
  int D.20398;
  const char * D.20400;
  int D.19904;
  int iftmp.12;
  int D.19903;
  const char[25] * D.20406;
  unsigned char D.20407;
  int D.20408;
  unsigned char D.20409;
  int D.20410;
  _Bool D.20411;
  _Bool D.20412;
  _Bool D.20413;
  const unsigned char * D.20416;
  unsigned char D.20417;
  int D.20418;
  const unsigned char * D.20419;
  unsigned char D.20420;
  int D.20421;
  _Bool D.20422;
  _Bool D.20423;
  const unsigned char * D.20426;
  unsigned char D.20427;
  int D.20428;
  const unsigned char * D.20429;
  unsigned char D.20430;
  int D.20431;
  _Bool D.20432;
  _Bool D.20433;
  const unsigned char * D.20436;
  unsigned char D.20437;
  int D.20438;
  const unsigned char * D.20439;
  unsigned char D.20440;
  int D.20441;
  int D.20445;
  <unnamed type> D.20446;
  struct ElevatedTrustCookie * cookie;

  cookie = data;
  if (managed == 0) goto <D.20262>; else goto <D.20264>;
  <D.20264>:
  D.20265 = BIT_FIELD_REF <*m, 8, 160>;
  D.20266 = D.20265 & 124;
  if (D.20266 != 0) goto <D.20262>; else goto <D.20263>;
  <D.20262>:
  D.20267 = 0;
  return D.20267;
  <D.20263>:
  D.20268 = m->klass;
  D.20269 = D.20268->image;
  D.20270 = mono_security_core_clr_is_platform_image (D.20269);
  if (D.20270 == 0) goto <D.20271>; else goto <D.20272>;
  <D.20271>:
  cookie->caller = m;
  D.20267 = 1;
  return D.20267;
  <D.20272>:
  D.20273 = cookie->depth;
  switch (D.20273) <default: <D.19907>, case 0: <D.19868>, case 1: <D.19906>>
  <D.19868>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.20268 = m->klass;
      __s2 = D.20268->name_space;
      D.20277 = "System.Security";
      D.20278 = MEM[(const unsigned char *)D.20277];
      D.20279 = (int) D.20278;
      D.20280 = *__s2;
      D.20281 = (int) D.20280;
      __result = D.20279 - D.20281;
      {
        D.20282 = __s2_len != 0;
        D.20283 = __result == 0;
        D.20284 = D.20282 & D.20283;
        if (D.20284 != 0) goto <D.20285>; else goto <D.20286>;
        <D.20285>:
        D.20287 = &MEM[(void *)"System.Security" + 1B];
        D.20288 = *D.20287;
        D.20289 = (int) D.20288;
        D.20290 = __s2 + 1;
        D.20291 = *D.20290;
        D.20292 = (int) D.20291;
        __result = D.20289 - D.20292;
        D.20293 = __s2_len > 1;
        D.20283 = __result == 0;
        D.20294 = D.20293 & D.20283;
        if (D.20294 != 0) goto <D.20295>; else goto <D.20296>;
        <D.20295>:
        D.20297 = &MEM[(void *)"System.Security" + 2B];
        D.20298 = *D.20297;
        D.20299 = (int) D.20298;
        D.20300 = __s2 + 2;
        D.20301 = *D.20300;
        D.20302 = (int) D.20301;
        __result = D.20299 - D.20302;
        D.20303 = __s2_len > 2;
        D.20283 = __result == 0;
        D.20304 = D.20303 & D.20283;
        if (D.20304 != 0) goto <D.20305>; else goto <D.20306>;
        <D.20305>:
        D.20307 = &MEM[(void *)"System.Security" + 3B];
        D.20308 = *D.20307;
        D.20309 = (int) D.20308;
        D.20310 = __s2 + 3;
        D.20311 = *D.20310;
        D.20312 = (int) D.20311;
        __result = D.20309 - D.20312;
        <D.20306>:
        <D.20296>:
        <D.20286>:
      }
      D.19876 = __result;
    }
    iftmp.9 = -D.19876;
    goto <D.20313>;
    <D.20276>:
    D.20268 = m->klass;
    D.20314 = D.20268->name_space;
    iftmp.9 = __builtin_strcmp (D.20314, "System.Security");
    <D.20313>:
    D.19877 = iftmp.9;
  }
  if (D.19877 != 0) goto <D.20315>; else goto <D.20316>;
  <D.20315>:
  D.20267 = 0;
  return D.20267;
  <D.20316>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.20268 = m->klass;
      __s2 = D.20268->name;
      D.20320 = "SecurityManager";
      D.20321 = MEM[(const unsigned char *)D.20320];
      D.20322 = (int) D.20321;
      D.20323 = *__s2;
      D.20324 = (int) D.20323;
      __result = D.20322 - D.20324;
      {
        D.20325 = __s2_len != 0;
        D.20326 = __result == 0;
        D.20327 = D.20325 & D.20326;
        if (D.20327 != 0) goto <D.20328>; else goto <D.20329>;
        <D.20328>:
        D.20330 = &MEM[(void *)"SecurityManager" + 1B];
        D.20331 = *D.20330;
        D.20332 = (int) D.20331;
        D.20333 = __s2 + 1;
        D.20334 = *D.20333;
        D.20335 = (int) D.20334;
        __result = D.20332 - D.20335;
        D.20336 = __s2_len > 1;
        D.20326 = __result == 0;
        D.20337 = D.20336 & D.20326;
        if (D.20337 != 0) goto <D.20338>; else goto <D.20339>;
        <D.20338>:
        D.20340 = &MEM[(void *)"SecurityManager" + 2B];
        D.20341 = *D.20340;
        D.20342 = (int) D.20341;
        D.20343 = __s2 + 2;
        D.20344 = *D.20343;
        D.20345 = (int) D.20344;
        __result = D.20342 - D.20345;
        D.20346 = __s2_len > 2;
        D.20326 = __result == 0;
        D.20347 = D.20346 & D.20326;
        if (D.20347 != 0) goto <D.20348>; else goto <D.20349>;
        <D.20348>:
        D.20350 = &MEM[(void *)"SecurityManager" + 3B];
        D.20351 = *D.20350;
        D.20352 = (int) D.20351;
        D.20353 = __s2 + 3;
        D.20354 = *D.20353;
        D.20355 = (int) D.20354;
        __result = D.20352 - D.20355;
        <D.20349>:
        <D.20339>:
        <D.20329>:
      }
      D.19885 = __result;
    }
    iftmp.10 = -D.19885;
    goto <D.20356>;
    <D.20319>:
    D.20268 = m->klass;
    D.20357 = D.20268->name;
    iftmp.10 = __builtin_strcmp (D.20357, "SecurityManager");
    <D.20356>:
    D.19886 = iftmp.10;
  }
  if (D.19886 != 0) goto <D.20358>; else goto <D.20359>;
  <D.20358>:
  D.20267 = 0;
  return D.20267;
  <D.20359>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.20363 = "EnsureElevatedPermissions";
      D.20364 = MEM[(const unsigned char *)D.20363];
      D.20365 = (int) D.20364;
      D.20366 = *__s2;
      D.20367 = (int) D.20366;
      __result = D.20365 - D.20367;
      {
        D.20368 = __s2_len != 0;
        D.20369 = __result == 0;
        D.20370 = D.20368 & D.20369;
        if (D.20370 != 0) goto <D.20371>; else goto <D.20372>;
        <D.20371>:
        D.20373 = &MEM[(void *)"EnsureElevatedPermissions" + 1B];
        D.20374 = *D.20373;
        D.20375 = (int) D.20374;
        D.20376 = __s2 + 1;
        D.20377 = *D.20376;
        D.20378 = (int) D.20377;
        __result = D.20375 - D.20378;
        D.20379 = __s2_len > 1;
        D.20369 = __result == 0;
        D.20380 = D.20379 & D.20369;
        if (D.20380 != 0) goto <D.20381>; else goto <D.20382>;
        <D.20381>:
        D.20383 = &MEM[(void *)"EnsureElevatedPermissions" + 2B];
        D.20384 = *D.20383;
        D.20385 = (int) D.20384;
        D.20386 = __s2 + 2;
        D.20387 = *D.20386;
        D.20388 = (int) D.20387;
        __result = D.20385 - D.20388;
        D.20389 = __s2_len > 2;
        D.20369 = __result == 0;
        D.20390 = D.20389 & D.20369;
        if (D.20390 != 0) goto <D.20391>; else goto <D.20392>;
        <D.20391>:
        D.20393 = &MEM[(void *)"EnsureElevatedPermissions" + 3B];
        D.20394 = *D.20393;
        D.20395 = (int) D.20394;
        D.20396 = __s2 + 3;
        D.20397 = *D.20396;
        D.20398 = (int) D.20397;
        __result = D.20395 - D.20398;
        <D.20392>:
        <D.20382>:
        <D.20372>:
      }
      D.19894 = __result;
    }
    iftmp.11 = -D.19894;
    goto <D.20399>;
    <D.20362>:
    D.20400 = m->name;
    iftmp.11 = __builtin_strcmp (D.20400, "EnsureElevatedPermissions");
    <D.20399>:
    D.19895 = iftmp.11;
  }
  if (D.19895 != 0) goto <D.20401>; else goto <D.20402>;
  <D.20401>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.20406 = "CheckElevatedPermissions";
      D.20407 = MEM[(const unsigned char *)D.20406];
      D.20408 = (int) D.20407;
      D.20409 = *__s2;
      D.20410 = (int) D.20409;
      __result = D.20408 - D.20410;
      {
        D.20411 = __s2_len != 0;
        D.20412 = __result == 0;
        D.20413 = D.20411 & D.20412;
        if (D.20413 != 0) goto <D.20414>; else goto <D.20415>;
        <D.20414>:
        D.20416 = &MEM[(void *)"CheckElevatedPermissions" + 1B];
        D.20417 = *D.20416;
        D.20418 = (int) D.20417;
        D.20419 = __s2 + 1;
        D.20420 = *D.20419;
        D.20421 = (int) D.20420;
        __result = D.20418 - D.20421;
        D.20422 = __s2_len > 1;
        D.20412 = __result == 0;
        D.20423 = D.20422 & D.20412;
        if (D.20423 != 0) goto <D.20424>; else goto <D.20425>;
        <D.20424>:
        D.20426 = &MEM[(void *)"CheckElevatedPermissions" + 2B];
        D.20427 = *D.20426;
        D.20428 = (int) D.20427;
        D.20429 = __s2 + 2;
        D.20430 = *D.20429;
        D.20431 = (int) D.20430;
        __result = D.20428 - D.20431;
        D.20432 = __s2_len > 2;
        D.20412 = __result == 0;
        D.20433 = D.20432 & D.20412;
        if (D.20433 != 0) goto <D.20434>; else goto <D.20435>;
        <D.20434>:
        D.20436 = &MEM[(void *)"CheckElevatedPermissions" + 3B];
        D.20437 = *D.20436;
        D.20438 = (int) D.20437;
        D.20439 = __s2 + 3;
        D.20440 = *D.20439;
        D.20441 = (int) D.20440;
        __result = D.20438 - D.20441;
        <D.20435>:
        <D.20425>:
        <D.20415>:
      }
      D.19903 = __result;
    }
    iftmp.12 = -D.19903;
    goto <D.20442>;
    <D.20405>:
    D.20400 = m->name;
    iftmp.12 = __builtin_strcmp (D.20400, "CheckElevatedPermissions");
    <D.20442>:
    D.19904 = iftmp.12;
  }
  if (D.19904 != 0) goto <D.20443>; else goto <D.20444>;
  <D.20443>:
  D.20267 = 0;
  return D.20267;
  <D.20444>:
  <D.20402>:
  cookie->depth = 1;
  goto <D.19905>;
  <D.19906>:
  cookie->depth = 2;
  goto <D.19905>;
  <D.19907>:
  D.20273 = cookie->depth;
  D.20445 = D.20273 + 1;
  cookie->depth = D.20445;
  D.20446 = mono_security_core_clr_method_level (m, 1);
  if (D.20446 == 0) goto <D.19905>; else goto <D.20447>;
  <D.20447>:
  cookie->caller = m;
  D.20267 = 1;
  return D.20267;
  <D.19905>:
  D.20267 = 0;
  return D.20267;
}


mono_security_core_clr_ensure_reflection_access_field (struct MonoClassField * field)
{
  <unnamed type> D.20449;
  <unnamed type> D.20452;
  unsigned int D.20453;
  struct MonoClass * D.20456;
  struct MonoImage * D.20457;
  int D.20458;
  struct MonoClass * D.20461;
  <unnamed type> D.20462;
  struct MonoException * D.20465;
  int D.20466;
  struct MonoException * D.20469;
  struct MonoMethod * caller;

  caller = get_reflection_caller ();
  D.20449 = mono_security_core_clr_method_level (caller, 1);
  if (D.20449 != 0) goto <D.20450>; else goto <D.20451>;
  <D.20450>:
  return;
  <D.20451>:
  D.20452 = mono_security_core_clr_get_options ();
  D.20453 = D.20452 & 1;
  if (D.20453 != 0) goto <D.20454>; else goto <D.20455>;
  <D.20454>:
  D.20456 = mono_field_get_parent (field);
  D.20457 = D.20456->image;
  D.20458 = mono_security_core_clr_is_platform_image (D.20457);
  if (D.20458 == 0) goto <D.20459>; else goto <D.20460>;
  <D.20459>:
  return;
  <D.20460>:
  <D.20455>:
  D.20461 = mono_field_get_parent (field);
  D.20462 = mono_security_core_clr_class_level (D.20461);
  if (D.20462 == 2) goto <D.20463>; else goto <D.20464>;
  <D.20463>:
  D.20465 = get_field_access_exception ("Transparent method %s cannot get or set Critical field %s.", caller, field);
  mono_raise_exception (D.20465);
  <D.20464>:
  D.20466 = check_field_access (caller, field);
  if (D.20466 == 0) goto <D.20467>; else goto <D.20468>;
  <D.20467>:
  D.20469 = get_field_access_exception ("Transparent method %s cannot get or set private/internal field %s.", caller, field);
  mono_raise_exception (D.20469);
  <D.20468>:
}


get_reflection_caller ()
{
  struct MonoMethod * m.13;
  _Bool D.20472;
  long int D.20473;
  long int D.20474;
  struct MonoMethod * D.20477;
  struct MonoMethod * m;

  try
    {
      m = 0B;
      mono_stack_walk_no_il (get_caller_no_reflection_related, &m);
      m.13 = m;
      D.20472 = m.13 == 0B;
      D.20473 = (long int) D.20472;
      D.20474 = __builtin_expect (D.20473, 0);
      if (D.20474 != 0) goto <D.20475>; else goto <D.20476>;
      <D.20475>:
      mono_trace (16, 64, "No caller outside reflection was found");
      <D.20476>:
      D.20477 = m;
      return D.20477;
    }
  finally
    {
      m = {CLOBBER};
    }
}


get_caller_no_reflection_related (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.20482;
  unsigned char D.20483;
  unsigned char D.20484;
  struct MonoClass * D.20487;
  char D.20491;
  struct MonoImage * D.20492;
  int D.20493;
  int D.19769;
  int iftmp.14;
  int D.19768;
  const char[18] * D.20499;
  unsigned char D.20500;
  int D.20501;
  unsigned char D.20502;
  int D.20503;
  _Bool D.20504;
  _Bool D.20505;
  _Bool D.20506;
  const unsigned char * D.20509;
  unsigned char D.20510;
  int D.20511;
  const unsigned char * D.20512;
  unsigned char D.20513;
  int D.20514;
  _Bool D.20515;
  _Bool D.20516;
  const unsigned char * D.20519;
  unsigned char D.20520;
  int D.20521;
  const unsigned char * D.20522;
  unsigned char D.20523;
  int D.20524;
  _Bool D.20525;
  _Bool D.20526;
  const unsigned char * D.20529;
  unsigned char D.20530;
  int D.20531;
  const unsigned char * D.20532;
  unsigned char D.20533;
  int D.20534;
  int D.19778;
  int iftmp.15;
  int D.19777;
  const char[23] * D.20541;
  unsigned char D.20542;
  int D.20543;
  unsigned char D.20544;
  int D.20545;
  _Bool D.20546;
  _Bool D.20547;
  _Bool D.20548;
  const unsigned char * D.20551;
  unsigned char D.20552;
  int D.20553;
  const unsigned char * D.20554;
  unsigned char D.20555;
  int D.20556;
  _Bool D.20557;
  _Bool D.20558;
  const unsigned char * D.20561;
  unsigned char D.20562;
  int D.20563;
  const unsigned char * D.20564;
  unsigned char D.20565;
  int D.20566;
  _Bool D.20567;
  _Bool D.20568;
  const unsigned char * D.20571;
  unsigned char D.20572;
  int D.20573;
  const unsigned char * D.20574;
  unsigned char D.20575;
  int D.20576;
  int D.19787;
  int iftmp.16;
  int D.19786;
  const char[7] * D.20583;
  unsigned char D.20584;
  int D.20585;
  unsigned char D.20586;
  int D.20587;
  _Bool D.20588;
  _Bool D.20589;
  _Bool D.20590;
  const unsigned char * D.20593;
  unsigned char D.20594;
  int D.20595;
  const unsigned char * D.20596;
  unsigned char D.20597;
  int D.20598;
  _Bool D.20599;
  _Bool D.20600;
  const unsigned char * D.20603;
  unsigned char D.20604;
  int D.20605;
  const unsigned char * D.20606;
  unsigned char D.20607;
  int D.20608;
  _Bool D.20609;
  _Bool D.20610;
  const unsigned char * D.20613;
  unsigned char D.20614;
  int D.20615;
  const unsigned char * D.20616;
  unsigned char D.20617;
  int D.20618;
  char D.20622;
  int D.19797;
  int iftmp.17;
  int D.19796;
  const char[10] * D.20628;
  unsigned char D.20629;
  int D.20630;
  unsigned char D.20631;
  int D.20632;
  _Bool D.20633;
  _Bool D.20634;
  _Bool D.20635;
  const unsigned char * D.20638;
  unsigned char D.20639;
  int D.20640;
  const unsigned char * D.20641;
  unsigned char D.20642;
  int D.20643;
  _Bool D.20644;
  _Bool D.20645;
  const unsigned char * D.20648;
  unsigned char D.20649;
  int D.20650;
  const unsigned char * D.20651;
  unsigned char D.20652;
  int D.20653;
  _Bool D.20654;
  _Bool D.20655;
  const unsigned char * D.20658;
  unsigned char D.20659;
  int D.20660;
  const unsigned char * D.20661;
  unsigned char D.20662;
  int D.20663;
  int D.19806;
  int iftmp.18;
  int D.19805;
  const char[5] * D.20674;
  unsigned char D.20675;
  int D.20676;
  unsigned char D.20677;
  int D.20678;
  _Bool D.20679;
  _Bool D.20680;
  _Bool D.20681;
  const unsigned char * D.20684;
  unsigned char D.20685;
  int D.20686;
  const unsigned char * D.20687;
  unsigned char D.20688;
  int D.20689;
  _Bool D.20690;
  _Bool D.20691;
  const unsigned char * D.20694;
  unsigned char D.20695;
  int D.20696;
  const unsigned char * D.20697;
  unsigned char D.20698;
  int D.20699;
  _Bool D.20700;
  _Bool D.20701;
  const unsigned char * D.20704;
  unsigned char D.20705;
  int D.20706;
  const unsigned char * D.20707;
  unsigned char D.20708;
  int D.20709;
  int D.19815;
  int iftmp.19;
  int D.19814;
  const char[9] * D.20715;
  unsigned char D.20716;
  int D.20717;
  unsigned char D.20718;
  int D.20719;
  _Bool D.20720;
  _Bool D.20721;
  _Bool D.20722;
  const unsigned char * D.20725;
  unsigned char D.20726;
  int D.20727;
  const unsigned char * D.20728;
  unsigned char D.20729;
  int D.20730;
  _Bool D.20731;
  _Bool D.20732;
  const unsigned char * D.20735;
  unsigned char D.20736;
  int D.20737;
  const unsigned char * D.20738;
  unsigned char D.20739;
  int D.20740;
  _Bool D.20741;
  _Bool D.20742;
  const unsigned char * D.20745;
  unsigned char D.20746;
  int D.20747;
  const unsigned char * D.20748;
  unsigned char D.20749;
  int D.20750;
  int D.19824;
  int iftmp.20;
  int D.19823;
  const char[13] * D.20755;
  unsigned char D.20756;
  int D.20757;
  unsigned char D.20758;
  int D.20759;
  _Bool D.20760;
  _Bool D.20761;
  _Bool D.20762;
  const unsigned char * D.20765;
  unsigned char D.20766;
  int D.20767;
  const unsigned char * D.20768;
  unsigned char D.20769;
  int D.20770;
  _Bool D.20771;
  _Bool D.20772;
  const unsigned char * D.20775;
  unsigned char D.20776;
  int D.20777;
  const unsigned char * D.20778;
  unsigned char D.20779;
  int D.20780;
  _Bool D.20781;
  _Bool D.20782;
  const unsigned char * D.20785;
  unsigned char D.20786;
  int D.20787;
  const unsigned char * D.20788;
  unsigned char D.20789;
  int D.20790;
  const char * D.20792;
  int D.19833;
  int iftmp.21;
  int D.19832;
  const char[9] * D.20802;
  unsigned char D.20803;
  int D.20804;
  unsigned char D.20805;
  int D.20806;
  _Bool D.20807;
  _Bool D.20808;
  _Bool D.20809;
  const unsigned char * D.20812;
  unsigned char D.20813;
  int D.20814;
  const unsigned char * D.20815;
  unsigned char D.20816;
  int D.20817;
  _Bool D.20818;
  _Bool D.20819;
  const unsigned char * D.20822;
  unsigned char D.20823;
  int D.20824;
  const unsigned char * D.20825;
  unsigned char D.20826;
  int D.20827;
  _Bool D.20828;
  _Bool D.20829;
  const unsigned char * D.20832;
  unsigned char D.20833;
  int D.20834;
  const unsigned char * D.20835;
  unsigned char D.20836;
  int D.20837;
  int D.19842;
  int iftmp.22;
  int D.19841;
  const char[18] * D.20843;
  unsigned char D.20844;
  int D.20845;
  unsigned char D.20846;
  int D.20847;
  _Bool D.20848;
  _Bool D.20849;
  _Bool D.20850;
  const unsigned char * D.20853;
  unsigned char D.20854;
  int D.20855;
  const unsigned char * D.20856;
  unsigned char D.20857;
  int D.20858;
  _Bool D.20859;
  _Bool D.20860;
  const unsigned char * D.20863;
  unsigned char D.20864;
  int D.20865;
  const unsigned char * D.20866;
  unsigned char D.20867;
  int D.20868;
  _Bool D.20869;
  _Bool D.20870;
  const unsigned char * D.20873;
  unsigned char D.20874;
  int D.20875;
  const unsigned char * D.20876;
  unsigned char D.20877;
  int D.20878;
  int D.19851;
  int iftmp.23;
  int D.19850;
  const char[14] * D.20883;
  unsigned char D.20884;
  int D.20885;
  unsigned char D.20886;
  int D.20887;
  _Bool D.20888;
  _Bool D.20889;
  _Bool D.20890;
  const unsigned char * D.20893;
  unsigned char D.20894;
  int D.20895;
  const unsigned char * D.20896;
  unsigned char D.20897;
  int D.20898;
  _Bool D.20899;
  _Bool D.20900;
  const unsigned char * D.20903;
  unsigned char D.20904;
  int D.20905;
  const unsigned char * D.20906;
  unsigned char D.20907;
  int D.20908;
  _Bool D.20909;
  _Bool D.20910;
  const unsigned char * D.20913;
  unsigned char D.20914;
  int D.20915;
  const unsigned char * D.20916;
  unsigned char D.20917;
  int D.20918;
  struct MonoMethod * D.20922;
  struct MonoMethod * * dest;
  const char * ns;

  dest = data;
  if (managed == 0) goto <D.20480>; else goto <D.20481>;
  <D.20480>:
  D.20482 = 0;
  return D.20482;
  <D.20481>:
  D.20483 = BIT_FIELD_REF <*m, 8, 160>;
  D.20484 = D.20483 & 124;
  if (D.20484 != 0) goto <D.20485>; else goto <D.20486>;
  <D.20485>:
  D.20482 = 0;
  return D.20482;
  <D.20486>:
  D.20487 = m->klass;
  ns = D.20487->name_space;
  if (ns == 0B) goto <D.20488>; else goto <D.20490>;
  <D.20490>:
  D.20491 = *ns;
  if (D.20491 != 83) goto <D.20488>; else goto <D.20489>;
  <D.20488>:
  *dest = m;
  D.20482 = 1;
  return D.20482;
  <D.20489>:
  D.20487 = m->klass;
  D.20492 = D.20487->image;
  D.20493 = mono_security_core_clr_is_platform_image (D.20492);
  if (D.20493 == 0) goto <D.20494>; else goto <D.20495>;
  <D.20494>:
  *dest = m;
  D.20482 = 1;
  return D.20482;
  <D.20495>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ns;
      D.20499 = "System.Reflection";
      D.20500 = MEM[(const unsigned char *)D.20499];
      D.20501 = (int) D.20500;
      D.20502 = *__s2;
      D.20503 = (int) D.20502;
      __result = D.20501 - D.20503;
      {
        D.20504 = __s2_len != 0;
        D.20505 = __result == 0;
        D.20506 = D.20504 & D.20505;
        if (D.20506 != 0) goto <D.20507>; else goto <D.20508>;
        <D.20507>:
        D.20509 = &MEM[(void *)"System.Reflection" + 1B];
        D.20510 = *D.20509;
        D.20511 = (int) D.20510;
        D.20512 = __s2 + 1;
        D.20513 = *D.20512;
        D.20514 = (int) D.20513;
        __result = D.20511 - D.20514;
        D.20515 = __s2_len > 1;
        D.20505 = __result == 0;
        D.20516 = D.20515 & D.20505;
        if (D.20516 != 0) goto <D.20517>; else goto <D.20518>;
        <D.20517>:
        D.20519 = &MEM[(void *)"System.Reflection" + 2B];
        D.20520 = *D.20519;
        D.20521 = (int) D.20520;
        D.20522 = __s2 + 2;
        D.20523 = *D.20522;
        D.20524 = (int) D.20523;
        __result = D.20521 - D.20524;
        D.20525 = __s2_len > 2;
        D.20505 = __result == 0;
        D.20526 = D.20525 & D.20505;
        if (D.20526 != 0) goto <D.20527>; else goto <D.20528>;
        <D.20527>:
        D.20529 = &MEM[(void *)"System.Reflection" + 3B];
        D.20530 = *D.20529;
        D.20531 = (int) D.20530;
        D.20532 = __s2 + 3;
        D.20533 = *D.20532;
        D.20534 = (int) D.20533;
        __result = D.20531 - D.20534;
        <D.20528>:
        <D.20518>:
        <D.20508>:
      }
      D.19768 = __result;
    }
    iftmp.14 = -D.19768;
    goto <D.20535>;
    <D.20498>:
    iftmp.14 = __builtin_strcmp (ns, "System.Reflection");
    <D.20535>:
    D.19769 = iftmp.14;
  }
  if (D.19769 == 0) goto <D.20536>; else goto <D.20537>;
  <D.20536>:
  D.20482 = 0;
  return D.20482;
  <D.20537>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ns;
      D.20541 = "System.Reflection.Emit";
      D.20542 = MEM[(const unsigned char *)D.20541];
      D.20543 = (int) D.20542;
      D.20544 = *__s2;
      D.20545 = (int) D.20544;
      __result = D.20543 - D.20545;
      {
        D.20546 = __s2_len != 0;
        D.20547 = __result == 0;
        D.20548 = D.20546 & D.20547;
        if (D.20548 != 0) goto <D.20549>; else goto <D.20550>;
        <D.20549>:
        D.20551 = &MEM[(void *)"System.Reflection.Emit" + 1B];
        D.20552 = *D.20551;
        D.20553 = (int) D.20552;
        D.20554 = __s2 + 1;
        D.20555 = *D.20554;
        D.20556 = (int) D.20555;
        __result = D.20553 - D.20556;
        D.20557 = __s2_len > 1;
        D.20547 = __result == 0;
        D.20558 = D.20557 & D.20547;
        if (D.20558 != 0) goto <D.20559>; else goto <D.20560>;
        <D.20559>:
        D.20561 = &MEM[(void *)"System.Reflection.Emit" + 2B];
        D.20562 = *D.20561;
        D.20563 = (int) D.20562;
        D.20564 = __s2 + 2;
        D.20565 = *D.20564;
        D.20566 = (int) D.20565;
        __result = D.20563 - D.20566;
        D.20567 = __s2_len > 2;
        D.20547 = __result == 0;
        D.20568 = D.20567 & D.20547;
        if (D.20568 != 0) goto <D.20569>; else goto <D.20570>;
        <D.20569>:
        D.20571 = &MEM[(void *)"System.Reflection.Emit" + 3B];
        D.20572 = *D.20571;
        D.20573 = (int) D.20572;
        D.20574 = __s2 + 3;
        D.20575 = *D.20574;
        D.20576 = (int) D.20575;
        __result = D.20573 - D.20576;
        <D.20570>:
        <D.20560>:
        <D.20550>:
      }
      D.19777 = __result;
    }
    iftmp.15 = -D.19777;
    goto <D.20577>;
    <D.20540>:
    iftmp.15 = __builtin_strcmp (ns, "System.Reflection.Emit");
    <D.20577>:
    D.19778 = iftmp.15;
  }
  if (D.19778 == 0) goto <D.20578>; else goto <D.20579>;
  <D.20578>:
  D.20482 = 0;
  return D.20482;
  <D.20579>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = ns;
      D.20583 = "System";
      D.20584 = MEM[(const unsigned char *)D.20583];
      D.20585 = (int) D.20584;
      D.20586 = *__s2;
      D.20587 = (int) D.20586;
      __result = D.20585 - D.20587;
      {
        D.20588 = __s2_len != 0;
        D.20589 = __result == 0;
        D.20590 = D.20588 & D.20589;
        if (D.20590 != 0) goto <D.20591>; else goto <D.20592>;
        <D.20591>:
        D.20593 = &MEM[(void *)"System" + 1B];
        D.20594 = *D.20593;
        D.20595 = (int) D.20594;
        D.20596 = __s2 + 1;
        D.20597 = *D.20596;
        D.20598 = (int) D.20597;
        __result = D.20595 - D.20598;
        D.20599 = __s2_len > 1;
        D.20589 = __result == 0;
        D.20600 = D.20599 & D.20589;
        if (D.20600 != 0) goto <D.20601>; else goto <D.20602>;
        <D.20601>:
        D.20603 = &MEM[(void *)"System" + 2B];
        D.20604 = *D.20603;
        D.20605 = (int) D.20604;
        D.20606 = __s2 + 2;
        D.20607 = *D.20606;
        D.20608 = (int) D.20607;
        __result = D.20605 - D.20608;
        D.20609 = __s2_len > 2;
        D.20589 = __result == 0;
        D.20610 = D.20609 & D.20589;
        if (D.20610 != 0) goto <D.20611>; else goto <D.20612>;
        <D.20611>:
        D.20613 = &MEM[(void *)"System" + 3B];
        D.20614 = *D.20613;
        D.20615 = (int) D.20614;
        D.20616 = __s2 + 3;
        D.20617 = *D.20616;
        D.20618 = (int) D.20617;
        __result = D.20615 - D.20618;
        <D.20612>:
        <D.20602>:
        <D.20592>:
      }
      D.19786 = __result;
    }
    iftmp.16 = -D.19786;
    goto <D.20619>;
    <D.20582>:
    iftmp.16 = __builtin_strcmp (ns, "System");
    <D.20619>:
    D.19787 = iftmp.16;
  }
  if (D.19787 == 0) goto <D.20620>; else goto <D.20621>;
  <D.20620>:
  {
    const char * kname;

    D.20487 = m->klass;
    kname = D.20487->name;
    D.20622 = *kname;
    if (D.20622 == 65) goto <D.20623>; else goto <D.20624>;
    <D.20623>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.20628 = "Activator";
        D.20629 = MEM[(const unsigned char *)D.20628];
        D.20630 = (int) D.20629;
        D.20631 = *__s2;
        D.20632 = (int) D.20631;
        __result = D.20630 - D.20632;
        {
          D.20633 = __s2_len != 0;
          D.20634 = __result == 0;
          D.20635 = D.20633 & D.20634;
          if (D.20635 != 0) goto <D.20636>; else goto <D.20637>;
          <D.20636>:
          D.20638 = &MEM[(void *)"Activator" + 1B];
          D.20639 = *D.20638;
          D.20640 = (int) D.20639;
          D.20641 = __s2 + 1;
          D.20642 = *D.20641;
          D.20643 = (int) D.20642;
          __result = D.20640 - D.20643;
          D.20644 = __s2_len > 1;
          D.20634 = __result == 0;
          D.20645 = D.20644 & D.20634;
          if (D.20645 != 0) goto <D.20646>; else goto <D.20647>;
          <D.20646>:
          D.20648 = &MEM[(void *)"Activator" + 2B];
          D.20649 = *D.20648;
          D.20650 = (int) D.20649;
          D.20651 = __s2 + 2;
          D.20652 = *D.20651;
          D.20653 = (int) D.20652;
          __result = D.20650 - D.20653;
          D.20654 = __s2_len > 2;
          D.20634 = __result == 0;
          D.20655 = D.20654 & D.20634;
          if (D.20655 != 0) goto <D.20656>; else goto <D.20657>;
          <D.20656>:
          D.20658 = &MEM[(void *)"Activator" + 3B];
          D.20659 = *D.20658;
          D.20660 = (int) D.20659;
          D.20661 = __s2 + 3;
          D.20662 = *D.20661;
          D.20663 = (int) D.20662;
          __result = D.20660 - D.20663;
          <D.20657>:
          <D.20647>:
          <D.20637>:
        }
        D.19796 = __result;
      }
      iftmp.17 = -D.19796;
      goto <D.20664>;
      <D.20627>:
      iftmp.17 = __builtin_strcmp (kname, "Activator");
      <D.20664>:
      D.19797 = iftmp.17;
    }
    if (D.19797 == 0) goto <D.20665>; else goto <D.20666>;
    <D.20665>:
    D.20482 = 0;
    return D.20482;
    <D.20666>:
    <D.20624>:
    D.20622 = *kname;
    if (D.20622 == 84) goto <D.20670>; else goto <D.20667>;
    <D.20670>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.20674 = "Type";
        D.20675 = MEM[(const unsigned char *)D.20674];
        D.20676 = (int) D.20675;
        D.20677 = *__s2;
        D.20678 = (int) D.20677;
        __result = D.20676 - D.20678;
        {
          D.20679 = __s2_len != 0;
          D.20680 = __result == 0;
          D.20681 = D.20679 & D.20680;
          if (D.20681 != 0) goto <D.20682>; else goto <D.20683>;
          <D.20682>:
          D.20684 = &MEM[(void *)"Type" + 1B];
          D.20685 = *D.20684;
          D.20686 = (int) D.20685;
          D.20687 = __s2 + 1;
          D.20688 = *D.20687;
          D.20689 = (int) D.20688;
          __result = D.20686 - D.20689;
          D.20690 = __s2_len > 1;
          D.20680 = __result == 0;
          D.20691 = D.20690 & D.20680;
          if (D.20691 != 0) goto <D.20692>; else goto <D.20693>;
          <D.20692>:
          D.20694 = &MEM[(void *)"Type" + 2B];
          D.20695 = *D.20694;
          D.20696 = (int) D.20695;
          D.20697 = __s2 + 2;
          D.20698 = *D.20697;
          D.20699 = (int) D.20698;
          __result = D.20696 - D.20699;
          D.20700 = __s2_len > 2;
          D.20680 = __result == 0;
          D.20701 = D.20700 & D.20680;
          if (D.20701 != 0) goto <D.20702>; else goto <D.20703>;
          <D.20702>:
          D.20704 = &MEM[(void *)"Type" + 3B];
          D.20705 = *D.20704;
          D.20706 = (int) D.20705;
          D.20707 = __s2 + 3;
          D.20708 = *D.20707;
          D.20709 = (int) D.20708;
          __result = D.20706 - D.20709;
          <D.20703>:
          <D.20693>:
          <D.20683>:
        }
        D.19805 = __result;
      }
      iftmp.18 = -D.19805;
      goto <D.20710>;
      <D.20673>:
      iftmp.18 = __builtin_strcmp (kname, "Type");
      <D.20710>:
      D.19806 = iftmp.18;
    }
    if (D.19806 == 0) goto <D.20668>; else goto <D.20667>;
    <D.20667>:
    D.20622 = *kname;
    if (D.20622 == 77) goto <D.20711>; else goto <D.20669>;
    <D.20711>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.20715 = "MonoType";
        D.20716 = MEM[(const unsigned char *)D.20715];
        D.20717 = (int) D.20716;
        D.20718 = *__s2;
        D.20719 = (int) D.20718;
        __result = D.20717 - D.20719;
        {
          D.20720 = __s2_len != 0;
          D.20721 = __result == 0;
          D.20722 = D.20720 & D.20721;
          if (D.20722 != 0) goto <D.20723>; else goto <D.20724>;
          <D.20723>:
          D.20725 = &MEM[(void *)"MonoType" + 1B];
          D.20726 = *D.20725;
          D.20727 = (int) D.20726;
          D.20728 = __s2 + 1;
          D.20729 = *D.20728;
          D.20730 = (int) D.20729;
          __result = D.20727 - D.20730;
          D.20731 = __s2_len > 1;
          D.20721 = __result == 0;
          D.20732 = D.20731 & D.20721;
          if (D.20732 != 0) goto <D.20733>; else goto <D.20734>;
          <D.20733>:
          D.20735 = &MEM[(void *)"MonoType" + 2B];
          D.20736 = *D.20735;
          D.20737 = (int) D.20736;
          D.20738 = __s2 + 2;
          D.20739 = *D.20738;
          D.20740 = (int) D.20739;
          __result = D.20737 - D.20740;
          D.20741 = __s2_len > 2;
          D.20721 = __result == 0;
          D.20742 = D.20741 & D.20721;
          if (D.20742 != 0) goto <D.20743>; else goto <D.20744>;
          <D.20743>:
          D.20745 = &MEM[(void *)"MonoType" + 3B];
          D.20746 = *D.20745;
          D.20747 = (int) D.20746;
          D.20748 = __s2 + 3;
          D.20749 = *D.20748;
          D.20750 = (int) D.20749;
          __result = D.20747 - D.20750;
          <D.20744>:
          <D.20734>:
          <D.20724>:
        }
        D.19814 = __result;
      }
      iftmp.19 = -D.19814;
      goto <D.20751>;
      <D.20714>:
      iftmp.19 = __builtin_strcmp (kname, "MonoType");
      <D.20751>:
      D.19815 = iftmp.19;
    }
    if (D.19815 == 0) goto <D.20668>; else goto <D.20669>;
    <D.20668>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.20755 = "InvokeMember";
        D.20756 = MEM[(const unsigned char *)D.20755];
        D.20757 = (int) D.20756;
        D.20758 = *__s2;
        D.20759 = (int) D.20758;
        __result = D.20757 - D.20759;
        {
          D.20760 = __s2_len != 0;
          D.20761 = __result == 0;
          D.20762 = D.20760 & D.20761;
          if (D.20762 != 0) goto <D.20763>; else goto <D.20764>;
          <D.20763>:
          D.20765 = &MEM[(void *)"InvokeMember" + 1B];
          D.20766 = *D.20765;
          D.20767 = (int) D.20766;
          D.20768 = __s2 + 1;
          D.20769 = *D.20768;
          D.20770 = (int) D.20769;
          __result = D.20767 - D.20770;
          D.20771 = __s2_len > 1;
          D.20761 = __result == 0;
          D.20772 = D.20771 & D.20761;
          if (D.20772 != 0) goto <D.20773>; else goto <D.20774>;
          <D.20773>:
          D.20775 = &MEM[(void *)"InvokeMember" + 2B];
          D.20776 = *D.20775;
          D.20777 = (int) D.20776;
          D.20778 = __s2 + 2;
          D.20779 = *D.20778;
          D.20780 = (int) D.20779;
          __result = D.20777 - D.20780;
          D.20781 = __s2_len > 2;
          D.20761 = __result == 0;
          D.20782 = D.20781 & D.20761;
          if (D.20782 != 0) goto <D.20783>; else goto <D.20784>;
          <D.20783>:
          D.20785 = &MEM[(void *)"InvokeMember" + 3B];
          D.20786 = *D.20785;
          D.20787 = (int) D.20786;
          D.20788 = __s2 + 3;
          D.20789 = *D.20788;
          D.20790 = (int) D.20789;
          __result = D.20787 - D.20790;
          <D.20784>:
          <D.20774>:
          <D.20764>:
        }
        D.19823 = __result;
      }
      iftmp.20 = -D.19823;
      goto <D.20791>;
      <D.20754>:
      D.20792 = m->name;
      iftmp.20 = __builtin_strcmp (D.20792, "InvokeMember");
      <D.20791>:
      D.19824 = iftmp.20;
    }
    if (D.19824 == 0) goto <D.20793>; else goto <D.20794>;
    <D.20793>:
    D.20482 = 0;
    return D.20482;
    <D.20794>:
    <D.20669>:
    D.20622 = *kname;
    if (D.20622 == 68) goto <D.20798>; else goto <D.20795>;
    <D.20798>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.20802 = "Delegate";
        D.20803 = MEM[(const unsigned char *)D.20802];
        D.20804 = (int) D.20803;
        D.20805 = *__s2;
        D.20806 = (int) D.20805;
        __result = D.20804 - D.20806;
        {
          D.20807 = __s2_len != 0;
          D.20808 = __result == 0;
          D.20809 = D.20807 & D.20808;
          if (D.20809 != 0) goto <D.20810>; else goto <D.20811>;
          <D.20810>:
          D.20812 = &MEM[(void *)"Delegate" + 1B];
          D.20813 = *D.20812;
          D.20814 = (int) D.20813;
          D.20815 = __s2 + 1;
          D.20816 = *D.20815;
          D.20817 = (int) D.20816;
          __result = D.20814 - D.20817;
          D.20818 = __s2_len > 1;
          D.20808 = __result == 0;
          D.20819 = D.20818 & D.20808;
          if (D.20819 != 0) goto <D.20820>; else goto <D.20821>;
          <D.20820>:
          D.20822 = &MEM[(void *)"Delegate" + 2B];
          D.20823 = *D.20822;
          D.20824 = (int) D.20823;
          D.20825 = __s2 + 2;
          D.20826 = *D.20825;
          D.20827 = (int) D.20826;
          __result = D.20824 - D.20827;
          D.20828 = __s2_len > 2;
          D.20808 = __result == 0;
          D.20829 = D.20828 & D.20808;
          if (D.20829 != 0) goto <D.20830>; else goto <D.20831>;
          <D.20830>:
          D.20832 = &MEM[(void *)"Delegate" + 3B];
          D.20833 = *D.20832;
          D.20834 = (int) D.20833;
          D.20835 = __s2 + 3;
          D.20836 = *D.20835;
          D.20837 = (int) D.20836;
          __result = D.20834 - D.20837;
          <D.20831>:
          <D.20821>:
          <D.20811>:
        }
        D.19832 = __result;
      }
      iftmp.21 = -D.19832;
      goto <D.20838>;
      <D.20801>:
      iftmp.21 = __builtin_strcmp (kname, "Delegate");
      <D.20838>:
      D.19833 = iftmp.21;
    }
    if (D.19833 == 0) goto <D.20796>; else goto <D.20795>;
    <D.20795>:
    D.20622 = *kname;
    if (D.20622 == 77) goto <D.20839>; else goto <D.20797>;
    <D.20839>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = kname;
        D.20843 = "MulticastDelegate";
        D.20844 = MEM[(const unsigned char *)D.20843];
        D.20845 = (int) D.20844;
        D.20846 = *__s2;
        D.20847 = (int) D.20846;
        __result = D.20845 - D.20847;
        {
          D.20848 = __s2_len != 0;
          D.20849 = __result == 0;
          D.20850 = D.20848 & D.20849;
          if (D.20850 != 0) goto <D.20851>; else goto <D.20852>;
          <D.20851>:
          D.20853 = &MEM[(void *)"MulticastDelegate" + 1B];
          D.20854 = *D.20853;
          D.20855 = (int) D.20854;
          D.20856 = __s2 + 1;
          D.20857 = *D.20856;
          D.20858 = (int) D.20857;
          __result = D.20855 - D.20858;
          D.20859 = __s2_len > 1;
          D.20849 = __result == 0;
          D.20860 = D.20859 & D.20849;
          if (D.20860 != 0) goto <D.20861>; else goto <D.20862>;
          <D.20861>:
          D.20863 = &MEM[(void *)"MulticastDelegate" + 2B];
          D.20864 = *D.20863;
          D.20865 = (int) D.20864;
          D.20866 = __s2 + 2;
          D.20867 = *D.20866;
          D.20868 = (int) D.20867;
          __result = D.20865 - D.20868;
          D.20869 = __s2_len > 2;
          D.20849 = __result == 0;
          D.20870 = D.20869 & D.20849;
          if (D.20870 != 0) goto <D.20871>; else goto <D.20872>;
          <D.20871>:
          D.20873 = &MEM[(void *)"MulticastDelegate" + 3B];
          D.20874 = *D.20873;
          D.20875 = (int) D.20874;
          D.20876 = __s2 + 3;
          D.20877 = *D.20876;
          D.20878 = (int) D.20877;
          __result = D.20875 - D.20878;
          <D.20872>:
          <D.20862>:
          <D.20852>:
        }
        D.19841 = __result;
      }
      iftmp.22 = -D.19841;
      goto <D.20879>;
      <D.20842>:
      iftmp.22 = __builtin_strcmp (kname, "MulticastDelegate");
      <D.20879>:
      D.19842 = iftmp.22;
    }
    if (D.19842 == 0) goto <D.20796>; else goto <D.20797>;
    <D.20796>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.20883 = "DynamicInvoke";
        D.20884 = MEM[(const unsigned char *)D.20883];
        D.20885 = (int) D.20884;
        D.20886 = *__s2;
        D.20887 = (int) D.20886;
        __result = D.20885 - D.20887;
        {
          D.20888 = __s2_len != 0;
          D.20889 = __result == 0;
          D.20890 = D.20888 & D.20889;
          if (D.20890 != 0) goto <D.20891>; else goto <D.20892>;
          <D.20891>:
          D.20893 = &MEM[(void *)"DynamicInvoke" + 1B];
          D.20894 = *D.20893;
          D.20895 = (int) D.20894;
          D.20896 = __s2 + 1;
          D.20897 = *D.20896;
          D.20898 = (int) D.20897;
          __result = D.20895 - D.20898;
          D.20899 = __s2_len > 1;
          D.20889 = __result == 0;
          D.20900 = D.20899 & D.20889;
          if (D.20900 != 0) goto <D.20901>; else goto <D.20902>;
          <D.20901>:
          D.20903 = &MEM[(void *)"DynamicInvoke" + 2B];
          D.20904 = *D.20903;
          D.20905 = (int) D.20904;
          D.20906 = __s2 + 2;
          D.20907 = *D.20906;
          D.20908 = (int) D.20907;
          __result = D.20905 - D.20908;
          D.20909 = __s2_len > 2;
          D.20889 = __result == 0;
          D.20910 = D.20909 & D.20889;
          if (D.20910 != 0) goto <D.20911>; else goto <D.20912>;
          <D.20911>:
          D.20913 = &MEM[(void *)"DynamicInvoke" + 3B];
          D.20914 = *D.20913;
          D.20915 = (int) D.20914;
          D.20916 = __s2 + 3;
          D.20917 = *D.20916;
          D.20918 = (int) D.20917;
          __result = D.20915 - D.20918;
          <D.20912>:
          <D.20902>:
          <D.20892>:
        }
        D.19850 = __result;
      }
      iftmp.23 = -D.19850;
      goto <D.20919>;
      <D.20882>:
      D.20792 = m->name;
      iftmp.23 = __builtin_strcmp (D.20792, "DynamicInvoke");
      <D.20919>:
      D.19851 = iftmp.23;
    }
    if (D.19851 != 0) goto <D.20920>; else goto <D.20921>;
    <D.20920>:
    D.20482 = 0;
    return D.20482;
    <D.20921>:
    <D.20797>:
  }
  <D.20621>:
  D.20922 = *dest;
  if (D.20922 == m) goto <D.20923>; else goto <D.20924>;
  <D.20923>:
  *dest = 0B;
  D.20482 = 0;
  return D.20482;
  <D.20924>:
  *dest = m;
  D.20482 = 1;
  return D.20482;
}


check_field_access (struct MonoMethod * caller, struct MonoClassField * field)
{
  int D.20928;
  gboolean D.20931;
  struct MonoClass * iftmp.24;
  unsigned int D.20933;
  unsigned int D.20934;

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

    try
      {
        mono_field_get_type_checked (field, &error);
        D.20928 = mono_error_ok (&error);
        if (D.20928 == 0) goto <D.20929>; else goto <D.20930>;
        <D.20929>:
        mono_error_cleanup (&error);
        D.20931 = 0;
        return D.20931;
        <D.20930>:
        D.20933 = mono_field_get_flags (field);
        D.20934 = D.20933 & 16;
        if (D.20934 == 0) goto <D.20935>; else goto <D.20936>;
        <D.20935>:
        iftmp.24 = mono_field_get_parent (field);
        goto <D.20937>;
        <D.20936>:
        iftmp.24 = 0B;
        <D.20937>:
        klass = iftmp.24;
        D.20931 = mono_method_can_access_field_full (caller, field, klass);
        return D.20931;
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.20927>:
  D.20931 = 0;
  return D.20931;
}


get_field_access_exception (const char * format, struct MonoMethod * caller, struct MonoClassField * field)
{
  struct MonoException * D.20940;
  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.20940 = ex;
  return D.20940;
}


mono_security_core_clr_ensure_reflection_access_method (struct MonoMethod * method)
{
  <unnamed type> D.20942;
  <unnamed type> D.20945;
  unsigned int D.20946;
  struct MonoClass * D.20949;
  struct MonoImage * D.20950;
  int D.20951;
  <unnamed type> D.20954;
  struct MonoException * D.20957;
  int D.20958;
  struct MonoException * D.20961;
  struct MonoMethod * caller;

  caller = get_reflection_caller ();
  D.20942 = mono_security_core_clr_method_level (caller, 1);
  if (D.20942 != 0) goto <D.20943>; else goto <D.20944>;
  <D.20943>:
  return;
  <D.20944>:
  D.20945 = mono_security_core_clr_get_options ();
  D.20946 = D.20945 & 1;
  if (D.20946 != 0) goto <D.20947>; else goto <D.20948>;
  <D.20947>:
  D.20949 = method->klass;
  D.20950 = D.20949->image;
  D.20951 = mono_security_core_clr_is_platform_image (D.20950);
  if (D.20951 == 0) goto <D.20952>; else goto <D.20953>;
  <D.20952>:
  return;
  <D.20953>:
  <D.20948>:
  D.20954 = mono_security_core_clr_method_level (method, 1);
  if (D.20954 == 2) goto <D.20955>; else goto <D.20956>;
  <D.20955>:
  D.20957 = get_method_access_exception ("Transparent method %s cannot invoke Critical method %s.", caller, method);
  mono_raise_exception (D.20957);
  <D.20956>:
  D.20958 = check_method_access (caller, method);
  if (D.20958 == 0) goto <D.20959>; else goto <D.20960>;
  <D.20959>:
  D.20961 = get_method_access_exception ("Transparent method %s cannot invoke private/internal method %s.", caller, method);
  mono_raise_exception (D.20961);
  <D.20960>:
}


check_method_access (struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoClass * iftmp.25;
  short unsigned int D.20966;
  int D.20967;
  int D.20968;
  gboolean D.20972;

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

    D.20966 = callee->flags;
    D.20967 = (int) D.20966;
    D.20968 = D.20967 & 16;
    if (D.20968 == 0) goto <D.20969>; else goto <D.20970>;
    <D.20969>:
    iftmp.25 = callee->klass;
    goto <D.20971>;
    <D.20970>:
    iftmp.25 = 0B;
    <D.20971>:
    klass = iftmp.25;
    D.20972 = mono_method_can_access_method_full (caller, callee, klass);
    return D.20972;
  }
  <D.20964>:
  D.20972 = 0;
  return D.20972;
}


get_method_access_exception (const char * format, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoException * D.20974;
  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.20974 = ex;
  return D.20974;
}


mono_security_core_clr_ensure_delegate_creation (struct MonoMethod * method, gboolean throwOnBindFailure)
{
  int D.20976;
  gboolean D.20979;
  <unnamed type> D.20980;
  <unnamed type> D.20983;
  struct MonoException * D.20988;
  <unnamed type> D.20989;
  unsigned int D.20990;
  struct MonoClass * D.20993;
  struct MonoImage * D.20994;
  int D.20995;
  int D.20998;
  struct MonoException * D.21001;
  struct MonoMethod * caller;

  D.20976 = can_avoid_corlib_reflection_delegate_optimization (method);
  if (D.20976 != 0) goto <D.20977>; else goto <D.20978>;
  <D.20977>:
  D.20979 = 1;
  return D.20979;
  <D.20978>:
  caller = get_reflection_caller ();
  D.20980 = mono_security_core_clr_method_level (caller, 1);
  if (D.20980 != 0) goto <D.20981>; else goto <D.20982>;
  <D.20981>:
  D.20979 = 1;
  return D.20979;
  <D.20982>:
  D.20983 = mono_security_core_clr_method_level (method, 1);
  if (D.20983 == 2) goto <D.20984>; else goto <D.20985>;
  <D.20984>:
  if (throwOnBindFailure == 0) goto <D.20986>; else goto <D.20987>;
  <D.20986>:
  D.20979 = 0;
  return D.20979;
  <D.20987>:
  D.20988 = get_argument_exception ("Transparent method %s cannot create a delegate on Critical method %s.", caller, method);
  mono_raise_exception (D.20988);
  <D.20985>:
  D.20989 = mono_security_core_clr_get_options ();
  D.20990 = D.20989 & 2;
  if (D.20990 != 0) goto <D.20991>; else goto <D.20992>;
  <D.20991>:
  D.20993 = method->klass;
  D.20994 = D.20993->image;
  D.20995 = mono_security_core_clr_is_platform_image (D.20994);
  if (D.20995 == 0) goto <D.20996>; else goto <D.20997>;
  <D.20996>:
  D.20979 = 1;
  return D.20979;
  <D.20997>:
  <D.20992>:
  D.20998 = check_method_access (caller, method);
  if (D.20998 == 0) goto <D.20999>; else goto <D.21000>;
  <D.20999>:
  D.21001 = get_method_access_exception ("Transparent method %s cannot create a delegate on private/internal method %s.", caller, method);
  mono_raise_exception (D.21001);
  <D.21000>:
  D.20979 = 1;
  return D.20979;
}


can_avoid_corlib_reflection_delegate_optimization (struct MonoMethod * method)
{
  struct MonoClass * D.21003;
  struct MonoImage * D.21004;
  int D.21005;
  gboolean D.21008;
  int D.19969;
  int iftmp.26;
  int D.19968;
  const char[18] * D.21012;
  unsigned char D.21013;
  int D.21014;
  unsigned char D.21015;
  int D.21016;
  _Bool D.21017;
  _Bool D.21018;
  _Bool D.21019;
  const unsigned char * D.21022;
  unsigned char D.21023;
  int D.21024;
  const unsigned char * D.21025;
  unsigned char D.21026;
  int D.21027;
  _Bool D.21028;
  _Bool D.21029;
  const unsigned char * D.21032;
  unsigned char D.21033;
  int D.21034;
  const unsigned char * D.21035;
  unsigned char D.21036;
  int D.21037;
  _Bool D.21038;
  _Bool D.21039;
  const unsigned char * D.21042;
  unsigned char D.21043;
  int D.21044;
  const unsigned char * D.21045;
  unsigned char D.21046;
  int D.21047;
  const char * D.21049;
  int D.19978;
  int iftmp.27;
  int D.19977;
  const char[13] * D.21055;
  unsigned char D.21056;
  int D.21057;
  unsigned char D.21058;
  int D.21059;
  _Bool D.21060;
  _Bool D.21061;
  _Bool D.21062;
  const unsigned char * D.21065;
  unsigned char D.21066;
  int D.21067;
  const unsigned char * D.21068;
  unsigned char D.21069;
  int D.21070;
  _Bool D.21071;
  _Bool D.21072;
  const unsigned char * D.21075;
  unsigned char D.21076;
  int D.21077;
  const unsigned char * D.21078;
  unsigned char D.21079;
  int D.21080;
  _Bool D.21081;
  _Bool D.21082;
  const unsigned char * D.21085;
  unsigned char D.21086;
  int D.21087;
  const unsigned char * D.21088;
  unsigned char D.21089;
  int D.21090;
  const char * D.21092;
  int D.19987;
  int iftmp.28;
  int D.19986;
  const char[19] * D.21100;
  unsigned char D.21101;
  int D.21102;
  unsigned char D.21103;
  int D.21104;
  _Bool D.21105;
  _Bool D.21106;
  _Bool D.21107;
  const unsigned char * D.21110;
  unsigned char D.21111;
  int D.21112;
  const unsigned char * D.21113;
  unsigned char D.21114;
  int D.21115;
  _Bool D.21116;
  _Bool D.21117;
  const unsigned char * D.21120;
  unsigned char D.21121;
  int D.21122;
  const unsigned char * D.21123;
  unsigned char D.21124;
  int D.21125;
  _Bool D.21126;
  _Bool D.21127;
  const unsigned char * D.21130;
  unsigned char D.21131;
  int D.21132;
  const unsigned char * D.21133;
  unsigned char D.21134;
  int D.21135;
  const char * D.21137;
  int D.19996;
  int iftmp.29;
  int D.19995;
  const char[25] * D.21142;
  unsigned char D.21143;
  int D.21144;
  unsigned char D.21145;
  int D.21146;
  _Bool D.21147;
  _Bool D.21148;
  _Bool D.21149;
  const unsigned char * D.21152;
  unsigned char D.21153;
  int D.21154;
  const unsigned char * D.21155;
  unsigned char D.21156;
  int D.21157;
  _Bool D.21158;
  _Bool D.21159;
  const unsigned char * D.21162;
  unsigned char D.21163;
  int D.21164;
  const unsigned char * D.21165;
  unsigned char D.21166;
  int D.21167;
  _Bool D.21168;
  _Bool D.21169;
  const unsigned char * D.21172;
  unsigned char D.21173;
  int D.21174;
  const unsigned char * D.21175;
  unsigned char D.21176;
  int D.21177;
  int D.20005;
  int iftmp.30;
  int D.20004;
  const char[10] * D.21183;
  unsigned char D.21184;
  int D.21185;
  unsigned char D.21186;
  int D.21187;
  _Bool D.21188;
  _Bool D.21189;
  _Bool D.21190;
  const unsigned char * D.21193;
  unsigned char D.21194;
  int D.21195;
  const unsigned char * D.21196;
  unsigned char D.21197;
  int D.21198;
  _Bool D.21199;
  _Bool D.21200;
  const unsigned char * D.21203;
  unsigned char D.21204;
  int D.21205;
  const unsigned char * D.21206;
  unsigned char D.21207;
  int D.21208;
  _Bool D.21209;
  _Bool D.21210;
  const unsigned char * D.21213;
  unsigned char D.21214;
  int D.21215;
  const unsigned char * D.21216;
  unsigned char D.21217;
  int D.21218;
  int D.20014;
  int iftmp.31;
  int D.20013;
  const char[14] * D.21227;
  unsigned char D.21228;
  int D.21229;
  unsigned char D.21230;
  int D.21231;
  _Bool D.21232;
  _Bool D.21233;
  _Bool D.21234;
  const unsigned char * D.21237;
  unsigned char D.21238;
  int D.21239;
  const unsigned char * D.21240;
  unsigned char D.21241;
  int D.21242;
  _Bool D.21243;
  _Bool D.21244;
  const unsigned char * D.21247;
  unsigned char D.21248;
  int D.21249;
  const unsigned char * D.21250;
  unsigned char D.21251;
  int D.21252;
  _Bool D.21253;
  _Bool D.21254;
  const unsigned char * D.21257;
  unsigned char D.21258;
  int D.21259;
  const unsigned char * D.21260;
  unsigned char D.21261;
  int D.21262;
  int D.20023;
  int iftmp.32;
  int D.20022;
  const char[27] * D.21268;
  unsigned char D.21269;
  int D.21270;
  unsigned char D.21271;
  int D.21272;
  _Bool D.21273;
  _Bool D.21274;
  _Bool D.21275;
  const unsigned char * D.21278;
  unsigned char D.21279;
  int D.21280;
  const unsigned char * D.21281;
  unsigned char D.21282;
  int D.21283;
  _Bool D.21284;
  _Bool D.21285;
  const unsigned char * D.21288;
  unsigned char D.21289;
  int D.21290;
  const unsigned char * D.21291;
  unsigned char D.21292;
  int D.21293;
  _Bool D.21294;
  _Bool D.21295;
  const unsigned char * D.21298;
  unsigned char D.21299;
  int D.21300;
  const unsigned char * D.21301;
  unsigned char D.21302;
  int D.21303;

  D.21003 = method->klass;
  D.21004 = D.21003->image;
  D.21005 = mono_security_core_clr_is_platform_image (D.21004);
  if (D.21005 == 0) goto <D.21006>; else goto <D.21007>;
  <D.21006>:
  D.21008 = 0;
  return D.21008;
  <D.21007>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.21003 = method->klass;
      __s2 = D.21003->name_space;
      D.21012 = "System.Reflection";
      D.21013 = MEM[(const unsigned char *)D.21012];
      D.21014 = (int) D.21013;
      D.21015 = *__s2;
      D.21016 = (int) D.21015;
      __result = D.21014 - D.21016;
      {
        D.21017 = __s2_len != 0;
        D.21018 = __result == 0;
        D.21019 = D.21017 & D.21018;
        if (D.21019 != 0) goto <D.21020>; else goto <D.21021>;
        <D.21020>:
        D.21022 = &MEM[(void *)"System.Reflection" + 1B];
        D.21023 = *D.21022;
        D.21024 = (int) D.21023;
        D.21025 = __s2 + 1;
        D.21026 = *D.21025;
        D.21027 = (int) D.21026;
        __result = D.21024 - D.21027;
        D.21028 = __s2_len > 1;
        D.21018 = __result == 0;
        D.21029 = D.21028 & D.21018;
        if (D.21029 != 0) goto <D.21030>; else goto <D.21031>;
        <D.21030>:
        D.21032 = &MEM[(void *)"System.Reflection" + 2B];
        D.21033 = *D.21032;
        D.21034 = (int) D.21033;
        D.21035 = __s2 + 2;
        D.21036 = *D.21035;
        D.21037 = (int) D.21036;
        __result = D.21034 - D.21037;
        D.21038 = __s2_len > 2;
        D.21018 = __result == 0;
        D.21039 = D.21038 & D.21018;
        if (D.21039 != 0) goto <D.21040>; else goto <D.21041>;
        <D.21040>:
        D.21042 = &MEM[(void *)"System.Reflection" + 3B];
        D.21043 = *D.21042;
        D.21044 = (int) D.21043;
        D.21045 = __s2 + 3;
        D.21046 = *D.21045;
        D.21047 = (int) D.21046;
        __result = D.21044 - D.21047;
        <D.21041>:
        <D.21031>:
        <D.21021>:
      }
      D.19968 = __result;
    }
    iftmp.26 = -D.19968;
    goto <D.21048>;
    <D.21011>:
    D.21003 = method->klass;
    D.21049 = D.21003->name_space;
    iftmp.26 = __builtin_strcmp (D.21049, "System.Reflection");
    <D.21048>:
    D.19969 = iftmp.26;
  }
  if (D.19969 != 0) goto <D.21050>; else goto <D.21051>;
  <D.21050>:
  D.21008 = 0;
  return D.21008;
  <D.21051>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.21003 = method->klass;
      __s2 = D.21003->name;
      D.21055 = "MonoProperty";
      D.21056 = MEM[(const unsigned char *)D.21055];
      D.21057 = (int) D.21056;
      D.21058 = *__s2;
      D.21059 = (int) D.21058;
      __result = D.21057 - D.21059;
      {
        D.21060 = __s2_len != 0;
        D.21061 = __result == 0;
        D.21062 = D.21060 & D.21061;
        if (D.21062 != 0) goto <D.21063>; else goto <D.21064>;
        <D.21063>:
        D.21065 = &MEM[(void *)"MonoProperty" + 1B];
        D.21066 = *D.21065;
        D.21067 = (int) D.21066;
        D.21068 = __s2 + 1;
        D.21069 = *D.21068;
        D.21070 = (int) D.21069;
        __result = D.21067 - D.21070;
        D.21071 = __s2_len > 1;
        D.21061 = __result == 0;
        D.21072 = D.21071 & D.21061;
        if (D.21072 != 0) goto <D.21073>; else goto <D.21074>;
        <D.21073>:
        D.21075 = &MEM[(void *)"MonoProperty" + 2B];
        D.21076 = *D.21075;
        D.21077 = (int) D.21076;
        D.21078 = __s2 + 2;
        D.21079 = *D.21078;
        D.21080 = (int) D.21079;
        __result = D.21077 - D.21080;
        D.21081 = __s2_len > 2;
        D.21061 = __result == 0;
        D.21082 = D.21081 & D.21061;
        if (D.21082 != 0) goto <D.21083>; else goto <D.21084>;
        <D.21083>:
        D.21085 = &MEM[(void *)"MonoProperty" + 3B];
        D.21086 = *D.21085;
        D.21087 = (int) D.21086;
        D.21088 = __s2 + 3;
        D.21089 = *D.21088;
        D.21090 = (int) D.21089;
        __result = D.21087 - D.21090;
        <D.21084>:
        <D.21074>:
        <D.21064>:
      }
      D.19977 = __result;
    }
    iftmp.27 = -D.19977;
    goto <D.21091>;
    <D.21054>:
    D.21003 = method->klass;
    D.21092 = D.21003->name;
    iftmp.27 = __builtin_strcmp (D.21092, "MonoProperty");
    <D.21091>:
    D.19978 = iftmp.27;
  }
  if (D.19978 == 0) goto <D.21093>; else goto <D.21094>;
  <D.21093>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.21100 = "GetterAdapterFrame";
      D.21101 = MEM[(const unsigned char *)D.21100];
      D.21102 = (int) D.21101;
      D.21103 = *__s2;
      D.21104 = (int) D.21103;
      __result = D.21102 - D.21104;
      {
        D.21105 = __s2_len != 0;
        D.21106 = __result == 0;
        D.21107 = D.21105 & D.21106;
        if (D.21107 != 0) goto <D.21108>; else goto <D.21109>;
        <D.21108>:
        D.21110 = &MEM[(void *)"GetterAdapterFrame" + 1B];
        D.21111 = *D.21110;
        D.21112 = (int) D.21111;
        D.21113 = __s2 + 1;
        D.21114 = *D.21113;
        D.21115 = (int) D.21114;
        __result = D.21112 - D.21115;
        D.21116 = __s2_len > 1;
        D.21106 = __result == 0;
        D.21117 = D.21116 & D.21106;
        if (D.21117 != 0) goto <D.21118>; else goto <D.21119>;
        <D.21118>:
        D.21120 = &MEM[(void *)"GetterAdapterFrame" + 2B];
        D.21121 = *D.21120;
        D.21122 = (int) D.21121;
        D.21123 = __s2 + 2;
        D.21124 = *D.21123;
        D.21125 = (int) D.21124;
        __result = D.21122 - D.21125;
        D.21126 = __s2_len > 2;
        D.21106 = __result == 0;
        D.21127 = D.21126 & D.21106;
        if (D.21127 != 0) goto <D.21128>; else goto <D.21129>;
        <D.21128>:
        D.21130 = &MEM[(void *)"GetterAdapterFrame" + 3B];
        D.21131 = *D.21130;
        D.21132 = (int) D.21131;
        D.21133 = __s2 + 3;
        D.21134 = *D.21133;
        D.21135 = (int) D.21134;
        __result = D.21132 - D.21135;
        <D.21129>:
        <D.21119>:
        <D.21109>:
      }
      D.19986 = __result;
    }
    iftmp.28 = -D.19986;
    goto <D.21136>;
    <D.21099>:
    D.21137 = method->name;
    iftmp.28 = __builtin_strcmp (D.21137, "GetterAdapterFrame");
    <D.21136>:
    D.19987 = iftmp.28;
  }
  if (D.19987 == 0) goto <D.21095>; else goto <D.21138>;
  <D.21138>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.21142 = "StaticGetterAdapterFrame";
      D.21143 = MEM[(const unsigned char *)D.21142];
      D.21144 = (int) D.21143;
      D.21145 = *__s2;
      D.21146 = (int) D.21145;
      __result = D.21144 - D.21146;
      {
        D.21147 = __s2_len != 0;
        D.21148 = __result == 0;
        D.21149 = D.21147 & D.21148;
        if (D.21149 != 0) goto <D.21150>; else goto <D.21151>;
        <D.21150>:
        D.21152 = &MEM[(void *)"StaticGetterAdapterFrame" + 1B];
        D.21153 = *D.21152;
        D.21154 = (int) D.21153;
        D.21155 = __s2 + 1;
        D.21156 = *D.21155;
        D.21157 = (int) D.21156;
        __result = D.21154 - D.21157;
        D.21158 = __s2_len > 1;
        D.21148 = __result == 0;
        D.21159 = D.21158 & D.21148;
        if (D.21159 != 0) goto <D.21160>; else goto <D.21161>;
        <D.21160>:
        D.21162 = &MEM[(void *)"StaticGetterAdapterFrame" + 2B];
        D.21163 = *D.21162;
        D.21164 = (int) D.21163;
        D.21165 = __s2 + 2;
        D.21166 = *D.21165;
        D.21167 = (int) D.21166;
        __result = D.21164 - D.21167;
        D.21168 = __s2_len > 2;
        D.21148 = __result == 0;
        D.21169 = D.21168 & D.21148;
        if (D.21169 != 0) goto <D.21170>; else goto <D.21171>;
        <D.21170>:
        D.21172 = &MEM[(void *)"StaticGetterAdapterFrame" + 3B];
        D.21173 = *D.21172;
        D.21174 = (int) D.21173;
        D.21175 = __s2 + 3;
        D.21176 = *D.21175;
        D.21177 = (int) D.21176;
        __result = D.21174 - D.21177;
        <D.21171>:
        <D.21161>:
        <D.21151>:
      }
      D.19995 = __result;
    }
    iftmp.29 = -D.19995;
    goto <D.21178>;
    <D.21141>:
    D.21137 = method->name;
    iftmp.29 = __builtin_strcmp (D.21137, "StaticGetterAdapterFrame");
    <D.21178>:
    D.19996 = iftmp.29;
  }
  if (D.19996 == 0) goto <D.21095>; else goto <D.21096>;
  <D.21095>:
  D.21008 = 1;
  return D.21008;
  <D.21096>:
  goto <D.21179>;
  <D.21094>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.21003 = method->klass;
      __s2 = D.21003->name;
      D.21183 = "EventInfo";
      D.21184 = MEM[(const unsigned char *)D.21183];
      D.21185 = (int) D.21184;
      D.21186 = *__s2;
      D.21187 = (int) D.21186;
      __result = D.21185 - D.21187;
      {
        D.21188 = __s2_len != 0;
        D.21189 = __result == 0;
        D.21190 = D.21188 & D.21189;
        if (D.21190 != 0) goto <D.21191>; else goto <D.21192>;
        <D.21191>:
        D.21193 = &MEM[(void *)"EventInfo" + 1B];
        D.21194 = *D.21193;
        D.21195 = (int) D.21194;
        D.21196 = __s2 + 1;
        D.21197 = *D.21196;
        D.21198 = (int) D.21197;
        __result = D.21195 - D.21198;
        D.21199 = __s2_len > 1;
        D.21189 = __result == 0;
        D.21200 = D.21199 & D.21189;
        if (D.21200 != 0) goto <D.21201>; else goto <D.21202>;
        <D.21201>:
        D.21203 = &MEM[(void *)"EventInfo" + 2B];
        D.21204 = *D.21203;
        D.21205 = (int) D.21204;
        D.21206 = __s2 + 2;
        D.21207 = *D.21206;
        D.21208 = (int) D.21207;
        __result = D.21205 - D.21208;
        D.21209 = __s2_len > 2;
        D.21189 = __result == 0;
        D.21210 = D.21209 & D.21189;
        if (D.21210 != 0) goto <D.21211>; else goto <D.21212>;
        <D.21211>:
        D.21213 = &MEM[(void *)"EventInfo" + 3B];
        D.21214 = *D.21213;
        D.21215 = (int) D.21214;
        D.21216 = __s2 + 3;
        D.21217 = *D.21216;
        D.21218 = (int) D.21217;
        __result = D.21215 - D.21218;
        <D.21212>:
        <D.21202>:
        <D.21192>:
      }
      D.20004 = __result;
    }
    iftmp.30 = -D.20004;
    goto <D.21219>;
    <D.21182>:
    D.21003 = method->klass;
    D.21092 = D.21003->name;
    iftmp.30 = __builtin_strcmp (D.21092, "EventInfo");
    <D.21219>:
    D.20005 = iftmp.30;
  }
  if (D.20005 == 0) goto <D.21220>; else goto <D.21221>;
  <D.21220>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.21227 = "AddEventFrame";
      D.21228 = MEM[(const unsigned char *)D.21227];
      D.21229 = (int) D.21228;
      D.21230 = *__s2;
      D.21231 = (int) D.21230;
      __result = D.21229 - D.21231;
      {
        D.21232 = __s2_len != 0;
        D.21233 = __result == 0;
        D.21234 = D.21232 & D.21233;
        if (D.21234 != 0) goto <D.21235>; else goto <D.21236>;
        <D.21235>:
        D.21237 = &MEM[(void *)"AddEventFrame" + 1B];
        D.21238 = *D.21237;
        D.21239 = (int) D.21238;
        D.21240 = __s2 + 1;
        D.21241 = *D.21240;
        D.21242 = (int) D.21241;
        __result = D.21239 - D.21242;
        D.21243 = __s2_len > 1;
        D.21233 = __result == 0;
        D.21244 = D.21243 & D.21233;
        if (D.21244 != 0) goto <D.21245>; else goto <D.21246>;
        <D.21245>:
        D.21247 = &MEM[(void *)"AddEventFrame" + 2B];
        D.21248 = *D.21247;
        D.21249 = (int) D.21248;
        D.21250 = __s2 + 2;
        D.21251 = *D.21250;
        D.21252 = (int) D.21251;
        __result = D.21249 - D.21252;
        D.21253 = __s2_len > 2;
        D.21233 = __result == 0;
        D.21254 = D.21253 & D.21233;
        if (D.21254 != 0) goto <D.21255>; else goto <D.21256>;
        <D.21255>:
        D.21257 = &MEM[(void *)"AddEventFrame" + 3B];
        D.21258 = *D.21257;
        D.21259 = (int) D.21258;
        D.21260 = __s2 + 3;
        D.21261 = *D.21260;
        D.21262 = (int) D.21261;
        __result = D.21259 - D.21262;
        <D.21256>:
        <D.21246>:
        <D.21236>:
      }
      D.20013 = __result;
    }
    iftmp.31 = -D.20013;
    goto <D.21263>;
    <D.21226>:
    D.21137 = method->name;
    iftmp.31 = __builtin_strcmp (D.21137, "AddEventFrame");
    <D.21263>:
    D.20014 = iftmp.31;
  }
  if (D.20014 == 0) goto <D.21222>; else goto <D.21264>;
  <D.21264>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.21268 = "StaticAddEventAdapterFrame";
      D.21269 = MEM[(const unsigned char *)D.21268];
      D.21270 = (int) D.21269;
      D.21271 = *__s2;
      D.21272 = (int) D.21271;
      __result = D.21270 - D.21272;
      {
        D.21273 = __s2_len != 0;
        D.21274 = __result == 0;
        D.21275 = D.21273 & D.21274;
        if (D.21275 != 0) goto <D.21276>; else goto <D.21277>;
        <D.21276>:
        D.21278 = &MEM[(void *)"StaticAddEventAdapterFrame" + 1B];
        D.21279 = *D.21278;
        D.21280 = (int) D.21279;
        D.21281 = __s2 + 1;
        D.21282 = *D.21281;
        D.21283 = (int) D.21282;
        __result = D.21280 - D.21283;
        D.21284 = __s2_len > 1;
        D.21274 = __result == 0;
        D.21285 = D.21284 & D.21274;
        if (D.21285 != 0) goto <D.21286>; else goto <D.21287>;
        <D.21286>:
        D.21288 = &MEM[(void *)"StaticAddEventAdapterFrame" + 2B];
        D.21289 = *D.21288;
        D.21290 = (int) D.21289;
        D.21291 = __s2 + 2;
        D.21292 = *D.21291;
        D.21293 = (int) D.21292;
        __result = D.21290 - D.21293;
        D.21294 = __s2_len > 2;
        D.21274 = __result == 0;
        D.21295 = D.21294 & D.21274;
        if (D.21295 != 0) goto <D.21296>; else goto <D.21297>;
        <D.21296>:
        D.21298 = &MEM[(void *)"StaticAddEventAdapterFrame" + 3B];
        D.21299 = *D.21298;
        D.21300 = (int) D.21299;
        D.21301 = __s2 + 3;
        D.21302 = *D.21301;
        D.21303 = (int) D.21302;
        __result = D.21300 - D.21303;
        <D.21297>:
        <D.21287>:
        <D.21277>:
      }
      D.20022 = __result;
    }
    iftmp.32 = -D.20022;
    goto <D.21304>;
    <D.21267>:
    D.21137 = method->name;
    iftmp.32 = __builtin_strcmp (D.21137, "StaticAddEventAdapterFrame");
    <D.21304>:
    D.20023 = iftmp.32;
  }
  if (D.20023 == 0) goto <D.21222>; else goto <D.21223>;
  <D.21222>:
  D.21008 = 1;
  return D.21008;
  <D.21223>:
  <D.21221>:
  <D.21179>:
  D.21008 = 0;
  return D.21008;
}


get_argument_exception (const char * format, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoException * D.21306;
  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.21306 = ex;
  return D.21306;
}


mono_security_core_clr_ensure_dynamic_method_resolved_object (void * ref, struct MonoClass * handle_class)
{
  struct MonoClass * D.21308;
  struct MonoImage * D.21311;
  int D.21312;
  int D.21315;
  struct MonoException * D.21318;
  struct MonoClass * D.21320;
  struct MonoClass * D.21323;
  struct MonoImage * D.21324;
  int D.21325;
  int D.21328;

  D.21308 = mono_defaults.fieldhandle_class;
  if (D.21308 == handle_class) goto <D.21309>; else goto <D.21310>;
  <D.21309>:
  {
    struct MonoClassField * field;
    struct MonoClass * klass;

    field = ref;
    klass = mono_field_get_parent (field);
    D.21311 = klass->image;
    D.21312 = mono_security_core_clr_is_platform_image (D.21311);
    if (D.21312 != 0) goto <D.21313>; else goto <D.21314>;
    <D.21313>:
    {
      struct MonoMethod * caller;

      caller = get_reflection_caller ();
      D.21315 = check_field_access (caller, field);
      if (D.21315 == 0) goto <D.21316>; else goto <D.21317>;
      <D.21316>:
      D.21318 = get_field_access_exception ("Dynamic method %s cannot create access private/internal field %s.", caller, field);
      return D.21318;
      <D.21317>:
    }
    <D.21314>:
  }
  goto <D.21319>;
  <D.21310>:
  D.21320 = mono_defaults.methodhandle_class;
  if (D.21320 == handle_class) goto <D.21321>; else goto <D.21322>;
  <D.21321>:
  {
    struct MonoMethod * method;

    method = ref;
    D.21323 = method->klass;
    D.21324 = D.21323->image;
    D.21325 = mono_security_core_clr_is_platform_image (D.21324);
    if (D.21325 != 0) goto <D.21326>; else goto <D.21327>;
    <D.21326>:
    {
      struct MonoMethod * caller;

      caller = get_reflection_caller ();
      D.21328 = check_method_access (caller, method);
      if (D.21328 == 0) goto <D.21329>; else goto <D.21330>;
      <D.21329>:
      D.21318 = get_method_access_exception ("Dynamic method %s cannot create access private/internal method %s.", caller, method);
      return D.21318;
      <D.21330>:
    }
    <D.21327>:
  }
  <D.21322>:
  <D.21319>:
  D.21318 = 0B;
  return D.21318;
}


mono_security_core_clr_can_access_internals (struct MonoImage * accessing, struct MonoImage * accessed)
{
  int D.21332;
  gboolean D.21335;
  int D.21336;
  struct MonoAssembly * D.21341;
  char * D.21342;
  struct MonoAssembly * D.21344;
  char * D.21345;
  int D.20050;
  _Bool D.21346;

  D.21332 = mono_security_core_clr_is_platform_image (accessed);
  if (D.21332 == 0) goto <D.21333>; else goto <D.21334>;
  <D.21333>:
  D.21335 = 1;
  return D.21335;
  <D.21334>:
  D.21336 = mono_security_core_clr_is_platform_image (accessing);
  if (D.21336 != 0) goto <D.21337>; else goto <D.21338>;
  <D.21337>:
  D.21335 = 1;
  return D.21335;
  <D.21338>:
  D.21341 = accessed->assembly;
  D.21342 = D.21341->basedir;
  if (D.21342 == 0B) goto <D.21339>; else goto <D.21343>;
  <D.21343>:
  D.21344 = accessing->assembly;
  D.21345 = D.21344->basedir;
  if (D.21345 == 0B) goto <D.21339>; else goto <D.21340>;
  <D.21339>:
  D.21335 = 0;
  return D.21335;
  <D.21340>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.21341 = accessed->assembly;
    D.21342 = D.21341->basedir;
    D.21344 = accessing->assembly;
    D.21345 = D.21344->basedir;
    D.20050 = __builtin_strcmp (D.21342, D.21345);
  }
  D.21346 = D.20050 == 0;
  D.21335 = (gboolean) D.21346;
  return D.21335;
}


mono_security_core_clr_is_field_access_allowed (struct MonoMethod * caller, struct MonoClassField * field)
{
  struct MonoClass * D.21348;
  <unnamed type> D.21349;
  struct MonoException * D.21352;
  <unnamed type> D.21356;

  D.21348 = mono_field_get_parent (field);
  D.21349 = mono_security_core_clr_class_level (D.21348);
  if (D.21349 != 2) goto <D.21350>; else goto <D.21351>;
  <D.21350>:
  D.21352 = 0B;
  return D.21352;
  <D.21351>:
  if (caller == 0B) goto <D.21353>; else goto <D.21355>;
  <D.21355>:
  D.21356 = mono_security_core_clr_method_level (caller, 1);
  if (D.21356 != 0) goto <D.21353>; else goto <D.21354>;
  <D.21353>:
  D.21352 = 0B;
  return D.21352;
  <D.21354>:
  D.21352 = get_field_access_exception ("Transparent method %s cannot call use Critical field %s.", caller, field);
  return D.21352;
}


mono_security_core_clr_is_call_allowed (struct MonoMethod * caller, struct MonoMethod * callee)
{
  <unnamed type> D.21358;
  struct MonoException * D.21361;
  <unnamed type> D.21365;

  D.21358 = mono_security_core_clr_method_level (callee, 1);
  if (D.21358 != 2) goto <D.21359>; else goto <D.21360>;
  <D.21359>:
  D.21361 = 0B;
  return D.21361;
  <D.21360>:
  if (caller == 0B) goto <D.21362>; else goto <D.21364>;
  <D.21364>:
  D.21365 = mono_security_core_clr_method_level (caller, 1);
  if (D.21365 != 0) goto <D.21362>; else goto <D.21363>;
  <D.21362>:
  D.21361 = 0B;
  return D.21361;
  <D.21363>:
  D.21361 = get_method_access_exception ("Transparent method %s cannot call Critical method %s.", caller, callee);
  return D.21361;
}


mono_security_core_clr_class_level (struct MonoClass * class)
{
  int mono_security_core_clr_test.33;
  struct MonoImage * D.21370;
  int D.21371;
  MonoSecurityCoreCLRLevel D.21374;

  mono_security_core_clr_test.33 = mono_security_core_clr_test;
  if (mono_security_core_clr_test.33 == 0) goto <D.21368>; else goto <D.21369>;
  <D.21368>:
  D.21370 = class->image;
  D.21371 = mono_security_core_clr_is_platform_image (D.21370);
  if (D.21371 == 0) goto <D.21372>; else goto <D.21373>;
  <D.21372>:
  D.21374 = 0;
  return D.21374;
  <D.21373>:
  <D.21369>:
  D.21374 = mono_security_core_clr_class_level_no_platform_check (class);
  return D.21374;
}


mono_security_core_clr_class_level_no_platform_check (struct MonoClass * class)
{
  struct MonoImage * D.21378;
  struct MonoClass * D.21381;
  MonoSecurityCoreCLRLevel D.21384;
  MonoSecurityCoreCLRLevel level;
  struct MonoCustomAttrInfo * cinfo;

  level = 0;
  cinfo = mono_custom_attrs_from_class (class);
  if (cinfo != 0B) goto <D.21376>; else goto <D.21377>;
  <D.21376>:
  D.21378 = class->image;
  level = mono_security_core_clr_level_from_cinfo (cinfo, D.21378);
  mono_custom_attrs_free (cinfo);
  <D.21377>:
  if (level == 0) goto <D.21379>; else goto <D.21380>;
  <D.21379>:
  D.21381 = class->nested_in;
  if (D.21381 != 0B) goto <D.21382>; else goto <D.21383>;
  <D.21382>:
  D.21381 = class->nested_in;
  level = mono_security_core_clr_class_level_no_platform_check (D.21381);
  <D.21383>:
  <D.21380>:
  D.21384 = level;
  return D.21384;
}


mono_security_core_clr_level_from_cinfo (struct MonoCustomAttrInfo * cinfo, struct MonoImage * image)
{
  struct MonoClass * D.21388;
  int D.21389;
  struct MonoClass * D.21394;
  int D.21395;
  MonoSecurityCoreCLRLevel D.21398;
  int level;

  level = 0;
  if (cinfo != 0B) goto <D.21386>; else goto <D.21387>;
  <D.21386>:
  D.21388 = security_safe_critical_attribute ();
  D.21389 = mono_custom_attrs_has_attr (cinfo, D.21388);
  if (D.21389 != 0) goto <D.21390>; else goto <D.21391>;
  <D.21390>:
  level = 1;
  <D.21391>:
  <D.21387>:
  if (cinfo != 0B) goto <D.21392>; else goto <D.21393>;
  <D.21392>:
  D.21394 = security_critical_attribute ();
  D.21395 = mono_custom_attrs_has_attr (cinfo, D.21394);
  if (D.21395 != 0) goto <D.21396>; else goto <D.21397>;
  <D.21396>:
  level = 2;
  <D.21397>:
  <D.21393>:
  D.21398 = (MonoSecurityCoreCLRLevel) level;
  return D.21398;
}


security_safe_critical_attribute ()
{
  struct MonoClass * class.34;
  struct MonoImage * D.21403;
  struct MonoClass * class.35;
  _Bool D.21405;
  long int D.21406;
  long int D.21407;
  struct MonoClass * D.21410;
  static struct MonoClass * class = 0B;

  class.34 = class;
  if (class.34 == 0B) goto <D.21401>; else goto <D.21402>;
  <D.21401>:
  D.21403 = mono_defaults.corlib;
  class.35 = mono_class_from_name (D.21403, "System.Security", "SecuritySafeCriticalAttribute");
  class = class.35;
  <D.21402>:
  class.34 = class;
  D.21405 = class.34 == 0B;
  D.21406 = (long int) D.21405;
  D.21407 = __builtin_expect (D.21406, 0);
  if (D.21407 != 0) goto <D.21408>; else goto <D.21409>;
  <D.21408>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-core-clr.c", 147, "class");
  <D.21409>:
  D.21410 = class;
  return D.21410;
}


security_critical_attribute ()
{
  struct MonoClass * class.36;
  struct MonoImage * D.21415;
  struct MonoClass * class.37;
  _Bool D.21417;
  long int D.21418;
  long int D.21419;
  struct MonoClass * D.21422;
  static struct MonoClass * class = 0B;

  class.36 = class;
  if (class.36 == 0B) goto <D.21413>; else goto <D.21414>;
  <D.21413>:
  D.21415 = mono_defaults.corlib;
  class.37 = mono_class_from_name (D.21415, "System.Security", "SecurityCriticalAttribute");
  class = class.37;
  <D.21414>:
  class.36 = class;
  D.21417 = class.36 == 0B;
  D.21418 = (long int) D.21417;
  D.21419 = __builtin_expect (D.21418, 0);
  if (D.21419 != 0) goto <D.21420>; else goto <D.21421>;
  <D.21420>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-core-clr.c", 134, "class");
  <D.21421>:
  D.21422 = class;
  return D.21422;
}


mono_security_core_clr_method_level (struct MonoMethod * method, gboolean with_class_level)
{
  MonoSecurityCoreCLRLevel D.21426;
  int mono_security_core_clr_test.38;
  struct MonoClass * D.21430;
  struct MonoImage * D.21431;
  int D.21432;
  _Bool D.21437;
  _Bool D.21438;
  _Bool D.21439;
  struct MonoCustomAttrInfo * cinfo;
  MonoSecurityCoreCLRLevel level;

  level = 0;
  if (method == 0B) goto <D.21424>; else goto <D.21425>;
  <D.21424>:
  D.21426 = level;
  return D.21426;
  <D.21425>:
  mono_security_core_clr_test.38 = mono_security_core_clr_test;
  if (mono_security_core_clr_test.38 == 0) goto <D.21428>; else goto <D.21429>;
  <D.21428>:
  D.21430 = method->klass;
  D.21431 = D.21430->image;
  D.21432 = mono_security_core_clr_is_platform_image (D.21431);
  if (D.21432 == 0) goto <D.21433>; else goto <D.21434>;
  <D.21433>:
  D.21426 = level;
  return D.21426;
  <D.21434>:
  <D.21429>:
  cinfo = mono_custom_attrs_from_method (method);
  if (cinfo != 0B) goto <D.21435>; else goto <D.21436>;
  <D.21435>:
  D.21430 = method->klass;
  D.21431 = D.21430->image;
  level = mono_security_core_clr_level_from_cinfo (cinfo, D.21431);
  mono_custom_attrs_free (cinfo);
  <D.21436>:
  D.21437 = with_class_level != 0;
  D.21438 = level == 0;
  D.21439 = D.21437 & D.21438;
  if (D.21439 != 0) goto <D.21440>; else goto <D.21441>;
  <D.21440>:
  D.21430 = method->klass;
  level = mono_security_core_clr_class_level (D.21430);
  <D.21441>:
  D.21426 = level;
  return D.21426;
}


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