mono_method_has_declsec (struct MonoMethod * method)
{
  unsigned char D.22297;
  unsigned char D.22298;
  _Bool D.22299;
  _Bool D.22300;
  _Bool D.22301;
  MonoBoolean D.22306;
  unsigned char D.22308;
  struct MonoClass * D.22313;
  unsigned int D.22314;
  unsigned int D.22315;
  short unsigned int D.22317;
  int D.22318;
  int D.22319;
  int D.22228;
  int iftmp.0;
  int D.22227;
  const char[7] * D.22323;
  unsigned char D.22324;
  int D.22325;
  unsigned char D.22326;
  int D.22327;
  _Bool D.22328;
  _Bool D.22329;
  _Bool D.22330;
  const unsigned char * D.22333;
  unsigned char D.22334;
  int D.22335;
  const unsigned char * D.22336;
  unsigned char D.22337;
  int D.22338;
  _Bool D.22339;
  _Bool D.22340;
  const unsigned char * D.22343;
  unsigned char D.22344;
  int D.22345;
  const unsigned char * D.22346;
  unsigned char D.22347;
  int D.22348;
  _Bool D.22349;
  _Bool D.22350;
  const unsigned char * D.22353;
  unsigned char D.22354;
  int D.22355;
  const unsigned char * D.22356;
  unsigned char D.22357;
  int D.22358;
  const char * D.22360;

  InterlockedIncrement (&mono_jit_stats.cas_declsec_check);
  D.22297 = BIT_FIELD_REF <*method, 8, 256>;
  D.22298 = D.22297 & 124;
  D.22299 = D.22298 == 24;
  D.22300 = D.22298 == 28;
  D.22301 = D.22299 | D.22300;
  if (D.22301 != 0) goto <D.22302>; else goto <D.22303>;
  <D.22302>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.22304>; else goto <D.22305>;
  <D.22304>:
  D.22306 = 0;
  return D.22306;
  <D.22305>:
  goto <D.22307>;
  <D.22303>:
  D.22297 = BIT_FIELD_REF <*method, 8, 256>;
  D.22308 = D.22297 & 124;
  if (D.22308 != 0) goto <D.22309>; else goto <D.22310>;
  <D.22309>:
  D.22306 = 0;
  return D.22306;
  <D.22310>:
  <D.22307>:
  D.22313 = method->klass;
  D.22314 = D.22313->flags;
  D.22315 = D.22314 & 262144;
  if (D.22315 != 0) goto <D.22311>; else goto <D.22316>;
  <D.22316>:
  D.22317 = method->flags;
  D.22318 = (int) D.22317;
  D.22319 = D.22318 & 16384;
  if (D.22319 != 0) goto <D.22311>; else goto <D.22312>;
  <D.22311>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.22323 = ".cctor";
      D.22324 = MEM[(const unsigned char *)D.22323];
      D.22325 = (int) D.22324;
      D.22326 = *__s2;
      D.22327 = (int) D.22326;
      __result = D.22325 - D.22327;
      {
        D.22328 = __s2_len != 0;
        D.22329 = __result == 0;
        D.22330 = D.22328 & D.22329;
        if (D.22330 != 0) goto <D.22331>; else goto <D.22332>;
        <D.22331>:
        D.22333 = &MEM[(void *)".cctor" + 1B];
        D.22334 = *D.22333;
        D.22335 = (int) D.22334;
        D.22336 = __s2 + 1;
        D.22337 = *D.22336;
        D.22338 = (int) D.22337;
        __result = D.22335 - D.22338;
        D.22339 = __s2_len > 1;
        D.22329 = __result == 0;
        D.22340 = D.22339 & D.22329;
        if (D.22340 != 0) goto <D.22341>; else goto <D.22342>;
        <D.22341>:
        D.22343 = &MEM[(void *)".cctor" + 2B];
        D.22344 = *D.22343;
        D.22345 = (int) D.22344;
        D.22346 = __s2 + 2;
        D.22347 = *D.22346;
        D.22348 = (int) D.22347;
        __result = D.22345 - D.22348;
        D.22349 = __s2_len > 2;
        D.22329 = __result == 0;
        D.22350 = D.22349 & D.22329;
        if (D.22350 != 0) goto <D.22351>; else goto <D.22352>;
        <D.22351>:
        D.22353 = &MEM[(void *)".cctor" + 3B];
        D.22354 = *D.22353;
        D.22355 = (int) D.22354;
        D.22356 = __s2 + 3;
        D.22357 = *D.22356;
        D.22358 = (int) D.22357;
        __result = D.22355 - D.22358;
        <D.22352>:
        <D.22342>:
        <D.22332>:
      }
      D.22227 = __result;
    }
    iftmp.0 = -D.22227;
    goto <D.22359>;
    <D.22322>:
    D.22360 = method->name;
    iftmp.0 = __builtin_strcmp (D.22360, ".cctor");
    <D.22359>:
    D.22228 = iftmp.0;
  }
  if (D.22228 != 0) goto <D.22361>; else goto <D.22362>;
  <D.22361>:
  D.22306 = 1;
  return D.22306;
  <D.22362>:
  <D.22312>:
  D.22306 = 0;
  return D.22306;
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.22364;
  unsigned int D.22365;

  D.22365 = __sync_add_and_fetch_4 (val, 1);
  D.22364 = (gint32) D.22365;
  return D.22364;
}


mono_declsec_cache_stack_modifiers (struct MonoJitInfo * jinfo)
{
  unsigned int D.22369;
  _Bool D.22370;
  <unnamed-signed:1> D.22371;
  unsigned int D.22372;
  _Bool D.22373;
  <unnamed-signed:1> D.22374;
  unsigned int D.22375;
  _Bool D.22376;
  <unnamed-signed:1> D.22377;
  struct MonoClass * D.22378;
  struct MonoMethodCasInfo * info;
  struct MonoMethod * method;
  guint32 flags;

  info = mono_jit_info_get_cas_info (jinfo);
  if (info == 0B) goto <D.22367>; else goto <D.22368>;
  <D.22367>:
  return;
  <D.22368>:
  method = jinfo_get_method (jinfo);
  flags = mono_declsec_flags_from_method (method);
  D.22369 = flags & 4;
  D.22370 = D.22369 != 0;
  D.22371 = (<unnamed-signed:1>) D.22370;
  info->cas_method_assert = D.22371;
  D.22372 = flags & 8;
  D.22373 = D.22372 != 0;
  D.22374 = (<unnamed-signed:1>) D.22373;
  info->cas_method_deny = D.22374;
  D.22375 = flags & 16;
  D.22376 = D.22375 != 0;
  D.22377 = (<unnamed-signed:1>) D.22376;
  info->cas_method_permitonly = D.22377;
  D.22378 = method->klass;
  flags = mono_declsec_flags_from_class (D.22378);
  D.22369 = flags & 4;
  D.22370 = D.22369 != 0;
  D.22371 = (<unnamed-signed:1>) D.22370;
  info->cas_class_assert = D.22371;
  D.22372 = flags & 8;
  D.22373 = D.22372 != 0;
  D.22374 = (<unnamed-signed:1>) D.22373;
  info->cas_class_deny = D.22374;
  D.22375 = flags & 16;
  D.22376 = D.22375 != 0;
  D.22377 = (<unnamed-signed:1>) D.22376;
  info->cas_class_permitonly = D.22377;
}


jinfo_get_method (struct MonoJitInfo * ji)
{
  struct MonoMethod * D.22380;

  D.22380 = mono_jit_info_get_method (ji);
  return D.22380;
}


mono_declsec_create_frame (struct MonoDomain * domain, struct MonoJitInfo * jinfo)
{
  struct MonoClass * D.22382;
  unsigned char D.22385;
  unsigned char D.22386;
  unsigned char D.22389;
  struct MonoReflectionMethod * D.22392;
  struct MonoReflectionMethod * * D.22393;
  struct MonoAppDomain * D.22394;
  struct MonoAppDomain * * D.22395;
  unsigned char D.22399;
  struct MonoDeclSecurityEntry * D.22401;
  unsigned char D.22404;
  struct MonoClass * D.22407;
  unsigned char D.22411;
  struct MonoDeclSecurityEntry * D.22413;
  unsigned char D.22416;
  unsigned char D.22422;
  struct MonoDeclSecurityEntry * D.22424;
  unsigned char D.22427;
  struct MonoSecurityFrame * D.22430;
  struct MonoSecurityFrame * frame;
  struct MonoMethodCasInfo * info;
  struct MonoMethod * method;

  D.22382 = mono_defaults.runtimesecurityframe_class;
  frame = mono_object_new (domain, D.22382);
  method = jinfo_get_method (jinfo);
  info = mono_jit_info_get_cas_info (jinfo);
  if (info != 0B) goto <D.22383>; else goto <D.22384>;
  <D.22383>:
  D.22385 = BIT_FIELD_REF <*info, 8, 0>;
  D.22386 = D.22385 & 1;
  if (D.22386 == 0) goto <D.22387>; else goto <D.22388>;
  <D.22387>:
  D.22389 = mono_method_has_declsec (method);
  if (D.22389 != 0) goto <D.22390>; else goto <D.22391>;
  <D.22390>:
  mono_declsec_cache_stack_modifiers (jinfo);
  <D.22391>:
  info->cas_inited = -1;
  <D.22388>:
  <D.22384>:
  D.22392 = mono_method_get_object (domain, method, 0B);
  D.22393 = &frame->method;
  mono_gc_wbarrier_set_field (frame, D.22393, D.22392);
  D.22394 = domain->domain;
  D.22395 = &frame->domain;
  mono_gc_wbarrier_set_field (frame, D.22395, D.22394);
  if (info != 0B) goto <D.22398>; else goto <D.22396>;
  <D.22398>:
  D.22385 = BIT_FIELD_REF <*info, 8, 0>;
  D.22399 = D.22385 & 16;
  if (D.22399 != 0) goto <D.22400>; else goto <D.22396>;
  <D.22400>:
  D.22401 = &frame->assert;
  mono_declsec_get_method_action (method, 3, D.22401);
  goto <D.22397>;
  <D.22396>:
  if (info != 0B) goto <D.22402>; else goto <D.22403>;
  <D.22402>:
  D.22385 = BIT_FIELD_REF <*info, 8, 0>;
  D.22404 = D.22385 & 2;
  if (D.22404 != 0) goto <D.22405>; else goto <D.22406>;
  <D.22405>:
  D.22401 = &frame->assert;
  D.22407 = method->klass;
  mono_declsec_get_class_action (D.22407, 3, D.22401);
  <D.22406>:
  <D.22403>:
  <D.22397>:
  if (info != 0B) goto <D.22410>; else goto <D.22408>;
  <D.22410>:
  D.22385 = BIT_FIELD_REF <*info, 8, 0>;
  D.22411 = D.22385 & 32;
  if (D.22411 != 0) goto <D.22412>; else goto <D.22408>;
  <D.22412>:
  D.22413 = &frame->deny;
  mono_declsec_get_method_action (method, 4, D.22413);
  goto <D.22409>;
  <D.22408>:
  if (info != 0B) goto <D.22414>; else goto <D.22415>;
  <D.22414>:
  D.22385 = BIT_FIELD_REF <*info, 8, 0>;
  D.22416 = D.22385 & 4;
  if (D.22416 != 0) goto <D.22417>; else goto <D.22418>;
  <D.22417>:
  D.22413 = &frame->deny;
  D.22407 = method->klass;
  mono_declsec_get_class_action (D.22407, 4, D.22413);
  <D.22418>:
  <D.22415>:
  <D.22409>:
  if (info != 0B) goto <D.22421>; else goto <D.22419>;
  <D.22421>:
  D.22385 = BIT_FIELD_REF <*info, 8, 0>;
  D.22422 = D.22385 & 64;
  if (D.22422 != 0) goto <D.22423>; else goto <D.22419>;
  <D.22423>:
  D.22424 = &frame->permitonly;
  mono_declsec_get_method_action (method, 5, D.22424);
  goto <D.22420>;
  <D.22419>:
  if (info != 0B) goto <D.22425>; else goto <D.22426>;
  <D.22425>:
  D.22385 = BIT_FIELD_REF <*info, 8, 0>;
  D.22427 = D.22385 & 8;
  if (D.22427 != 0) goto <D.22428>; else goto <D.22429>;
  <D.22428>:
  D.22424 = &frame->permitonly;
  D.22407 = method->klass;
  mono_declsec_get_class_action (D.22407, 5, D.22424);
  <D.22429>:
  <D.22426>:
  <D.22420>:
  D.22430 = frame;
  return D.22430;
}


mono_declsec_linkdemand (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoClass * D.22432;
  struct MonoImage * D.22433;
  struct MonoImage * D.22434;
  struct MonoClass * D.22437;
  struct MonoImage * D.22438;
  guint32 D.22441;
  short unsigned int D.22442;
  int D.22443;
  int D.22444;
  int D.22447;
  short unsigned int D.22451;
  int D.22452;
  int D.22453;
  int D.22456;
  int D.22461;
  unsigned char D.22466;
  int D.22469;
  guint32 violation;

  violation = 0;
  D.22432 = caller->klass;
  D.22433 = D.22432->image;
  D.22434 = mono_defaults.corlib;
  if (D.22433 == D.22434) goto <D.22435>; else goto <D.22436>;
  <D.22435>:
  D.22437 = callee->klass;
  D.22438 = D.22437->image;
  D.22434 = mono_defaults.corlib;
  if (D.22438 == D.22434) goto <D.22439>; else goto <D.22440>;
  <D.22439>:
  D.22441 = violation;
  return D.22441;
  <D.22440>:
  <D.22436>:
  D.22442 = callee->iflags;
  D.22443 = (int) D.22442;
  D.22444 = D.22443 & 4096;
  if (D.22444 != 0) goto <D.22445>; else goto <D.22446>;
  <D.22445>:
  D.22447 = mono_declsec_linkdemand_icall (domain, caller, callee);
  if (D.22447 != 0) goto <D.22448>; else goto <D.22449>;
  <D.22448>:
  violation = 4;
  <D.22449>:
  goto <D.22450>;
  <D.22446>:
  D.22451 = callee->flags;
  D.22452 = (int) D.22451;
  D.22453 = D.22452 & 8192;
  if (D.22453 != 0) goto <D.22454>; else goto <D.22455>;
  <D.22454>:
  D.22456 = mono_declsec_linkdemand_pinvoke (domain, caller, callee);
  if (D.22456 != 0) goto <D.22457>; else goto <D.22458>;
  <D.22457>:
  violation = 8;
  <D.22458>:
  <D.22455>:
  <D.22450>:
  if (violation == 0) goto <D.22459>; else goto <D.22460>;
  <D.22459>:
  D.22461 = mono_declsec_linkdemand_aptc (domain, caller, callee);
  if (D.22461 != 0) goto <D.22462>; else goto <D.22463>;
  <D.22462>:
  violation = 2;
  <D.22463>:
  <D.22460>:
  if (violation == 0) goto <D.22464>; else goto <D.22465>;
  <D.22464>:
  D.22466 = mono_method_has_declsec (callee);
  if (D.22466 != 0) goto <D.22467>; else goto <D.22468>;
  <D.22467>:
  D.22469 = mono_declsec_linkdemand_standard (domain, caller, callee);
  if (D.22469 != 0) goto <D.22470>; else goto <D.22471>;
  <D.22470>:
  violation = 1;
  <D.22471>:
  <D.22468>:
  <D.22465>:
  D.22441 = violation;
  return D.22441;
}


mono_declsec_linkdemand_icall (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * icall)
{
  struct MonoClass * D.22473;
  struct MonoImage * D.22474;
  <unnamed-unsigned:2> D.22475;
  int D.22476;
  int D.22477;
  <unnamed-unsigned:2> iftmp.1;
  unsigned int size.2;
  int size.3;
  int D.22483;
  int D.22487;
  gboolean D.22490;
  struct MonoClass * D.22491;
  struct MonoImage * D.22492;
  int D.22493;
  _Bool D.22494;
  struct MonoAssembly * assembly;

  InterlockedIncrement (&mono_jit_stats.cas_linkdemand_icall);
  D.22473 = icall->klass;
  D.22474 = D.22473->image;
  assembly = mono_image_get_assembly (D.22474);
  D.22475 = assembly->ecma;
  D.22476 = (int) D.22475;
  D.22477 = D.22476 & 2;
  if (D.22477 == 0) goto <D.22478>; else goto <D.22479>;
  <D.22478>:
  {
    guint32 size;
    const char * pk;

    try
      {
        size = 0;
        D.22473 = icall->klass;
        D.22474 = D.22473->image;
        pk = mono_image_get_public_key (D.22474, &size);
        size.2 = size;
        size.3 = (int) size.2;
        D.22483 = mono_is_ecma_key (pk, size.3);
        if (D.22483 != 0) goto <D.22484>; else goto <D.22485>;
        <D.22484>:
        iftmp.1 = 3;
        goto <D.22486>;
        <D.22485>:
        iftmp.1 = 2;
        <D.22486>:
        assembly->ecma = iftmp.1;
      }
    finally
      {
        size = {CLOBBER};
      }
  }
  <D.22479>:
  D.22475 = assembly->ecma;
  D.22476 = (int) D.22475;
  D.22487 = D.22476 & 1;
  if (D.22487 != 0) goto <D.22488>; else goto <D.22489>;
  <D.22488>:
  D.22490 = 0;
  return D.22490;
  <D.22489>:
  D.22491 = caller->klass;
  D.22492 = D.22491->image;
  assembly = mono_image_get_assembly (D.22492);
  D.22493 = mono_declsec_is_assembly_fulltrust (domain, assembly);
  D.22494 = D.22493 == 0;
  D.22490 = (gboolean) D.22494;
  return D.22490;
}


mono_declsec_is_assembly_fulltrust (struct MonoDomain * domain, struct MonoAssembly * assembly)
{
  <unnamed-unsigned:2> D.22496;
  int D.22497;
  int D.22498;
  _Bool D.22501;
  _Bool D.22502;
  _Bool D.22503;
  struct MonoMethod * D.22506;
  void * D.22507;
  unsigned char D.22508;
  gboolean D.22511;
  int D.22512;

  D.22496 = assembly->fulltrust;
  D.22497 = (int) D.22496;
  D.22498 = D.22497 & 2;
  if (D.22498 == 0) goto <D.22499>; else goto <D.22500>;
  <D.22499>:
  {
    struct MonoReflectionAssembly * refass;
    struct MonoSecurityManager * secman;

    refass = mono_assembly_get_object (domain, assembly);
    secman = mono_security_manager_get_methods ();
    D.22501 = secman != 0B;
    D.22502 = refass != 0B;
    D.22503 = D.22501 & D.22502;
    if (D.22503 != 0) goto <D.22504>; else goto <D.22505>;
    <D.22504>:
    {
      struct MonoObject * res;
      void * args[1];

      try
        {
          args[0] = refass;
          D.22506 = secman->linkdemandfulltrust;
          res = mono_runtime_invoke (D.22506, 0B, &args, 0B);
          D.22507 = mono_object_unbox (res);
          D.22508 = MEM[(MonoBoolean *)D.22507];
          if (D.22508 != 0) goto <D.22509>; else goto <D.22510>;
          <D.22509>:
          assembly->fulltrust = 3;
          D.22511 = 1;
          return D.22511;
          <D.22510>:
        }
      finally
        {
          args = {CLOBBER};
        }
    }
    <D.22505>:
    assembly->fulltrust = 2;
    D.22511 = 0;
    return D.22511;
  }
  <D.22500>:
  D.22496 = assembly->fulltrust;
  D.22512 = (int) D.22496;
  D.22511 = D.22512 & 1;
  return D.22511;
}


mono_declsec_linkdemand_pinvoke (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * native)
{
  struct MonoClass * D.22516;
  struct MonoImage * D.22517;
  <unnamed-unsigned:2> D.22518;
  int D.22519;
  int D.22520;
  <unnamed-unsigned:2> D.22523;
  unsigned int D.22524;
  unsigned int D.22525;
  gboolean D.22528;
  _Bool D.22529;
  _Bool D.22530;
  _Bool D.22531;
  struct MonoMethod * D.22534;
  void * D.22535;
  unsigned char D.22536;
  int D.22539;
  struct MonoAssembly * assembly;

  D.22516 = caller->klass;
  D.22517 = D.22516->image;
  assembly = mono_image_get_assembly (D.22517);
  InterlockedIncrement (&mono_jit_stats.cas_linkdemand_pinvoke);
  D.22518 = assembly->unmanaged;
  D.22519 = (int) D.22518;
  D.22520 = D.22519 & 2;
  if (D.22520 == 0) goto <D.22521>; else goto <D.22522>;
  <D.22521>:
  D.22523 = assembly->fulltrust;
  D.22524 = (unsigned int) D.22523;
  D.22525 = D.22524 & 3;
  if (D.22525 == 3) goto <D.22526>; else goto <D.22527>;
  <D.22526>:
  assembly->unmanaged = 3;
  D.22528 = 0;
  return D.22528;
  <D.22527>:
  {
    struct MonoReflectionAssembly * refass;
    struct MonoSecurityManager * secman;

    refass = mono_assembly_get_object (domain, assembly);
    secman = mono_security_manager_get_methods ();
    D.22529 = secman != 0B;
    D.22530 = refass != 0B;
    D.22531 = D.22529 & D.22530;
    if (D.22531 != 0) goto <D.22532>; else goto <D.22533>;
    <D.22532>:
    {
      struct MonoObject * res;
      void * args[1];

      try
        {
          args[0] = refass;
          D.22534 = secman->linkdemandunmanaged;
          res = mono_runtime_invoke (D.22534, 0B, &args, 0B);
          D.22535 = mono_object_unbox (res);
          D.22536 = MEM[(MonoBoolean *)D.22535];
          if (D.22536 != 0) goto <D.22537>; else goto <D.22538>;
          <D.22537>:
          assembly->unmanaged = 3;
          D.22528 = 0;
          return D.22528;
          <D.22538>:
        }
      finally
        {
          args = {CLOBBER};
        }
    }
    <D.22533>:
  }
  assembly->unmanaged = 2;
  <D.22522>:
  D.22518 = assembly->unmanaged;
  D.22519 = (int) D.22518;
  D.22539 = D.22519 & 1;
  if (D.22539 != 0) goto <D.22540>; else goto <D.22541>;
  <D.22540>:
  D.22528 = 0;
  return D.22528;
  <D.22541>:
  D.22528 = 1;
  return D.22528;
}


mono_declsec_linkdemand_aptc (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoClass * D.22545;
  struct MonoImage * D.22546;
  struct MonoClass * D.22547;
  struct MonoImage * D.22548;
  gboolean D.22551;
  unsigned int D.22554;
  unsigned int D.22555;
  short unsigned int D.22557;
  int D.22558;
  int D.22559;
  const char * D.22562;
  unsigned int size.4;
  <unnamed-unsigned:2> D.22565;
  int D.22566;
  int D.22567;
  _Bool D.22570;
  _Bool D.22571;
  _Bool D.22572;
  struct MonoClass * D.22575;
  <unnamed-unsigned:2> iftmp.5;
  int D.22582;
  int D.22585;
  struct MonoSecurityManager * secman;
  struct MonoAssembly * assembly;
  guint32 size;

  try
    {
      secman = 0B;
      size = 0;
      InterlockedIncrement (&mono_jit_stats.cas_linkdemand_aptc);
      D.22545 = caller->klass;
      D.22546 = D.22545->image;
      D.22547 = callee->klass;
      D.22548 = D.22547->image;
      if (D.22546 == D.22548) goto <D.22549>; else goto <D.22550>;
      <D.22549>:
      D.22551 = 0;
      return D.22551;
      <D.22550>:
      D.22547 = callee->klass;
      D.22554 = D.22547->flags;
      D.22555 = D.22554 & 1;
      if (D.22555 == 0) goto <D.22552>; else goto <D.22556>;
      <D.22556>:
      D.22557 = callee->flags;
      D.22558 = (int) D.22557;
      D.22559 = D.22558 & 6;
      if (D.22559 == 0) goto <D.22552>; else goto <D.22553>;
      <D.22552>:
      D.22551 = 0;
      return D.22551;
      <D.22553>:
      D.22547 = callee->klass;
      D.22548 = D.22547->image;
      D.22562 = mono_image_get_public_key (D.22548, &size);
      if (D.22562 == 0B) goto <D.22560>; else goto <D.22563>;
      <D.22563>:
      size.4 = size;
      if (size.4 <= 15) goto <D.22560>; else goto <D.22561>;
      <D.22560>:
      D.22551 = 0;
      return D.22551;
      <D.22561>:
      D.22547 = callee->klass;
      D.22548 = D.22547->image;
      assembly = mono_image_get_assembly (D.22548);
      D.22565 = assembly->aptc;
      D.22566 = (int) D.22565;
      D.22567 = D.22566 & 2;
      if (D.22567 == 0) goto <D.22568>; else goto <D.22569>;
      <D.22568>:
      {
        struct MonoCustomAttrInfo * cinfo;
        gboolean result;

        cinfo = mono_custom_attrs_from_assembly (assembly);
        result = 0;
        secman = mono_security_manager_get_methods ();
        D.22570 = secman != 0B;
        D.22571 = cinfo != 0B;
        D.22572 = D.22570 & D.22571;
        if (D.22572 != 0) goto <D.22573>; else goto <D.22574>;
        <D.22573>:
        D.22575 = secman->allowpartiallytrustedcallers;
        result = mono_custom_attrs_has_attr (cinfo, D.22575);
        <D.22574>:
        if (cinfo != 0B) goto <D.22576>; else goto <D.22577>;
        <D.22576>:
        mono_custom_attrs_free (cinfo);
        <D.22577>:
        if (result != 0) goto <D.22579>; else goto <D.22580>;
        <D.22579>:
        iftmp.5 = 3;
        goto <D.22581>;
        <D.22580>:
        iftmp.5 = 2;
        <D.22581>:
        assembly->aptc = iftmp.5;
      }
      <D.22569>:
      D.22565 = assembly->aptc;
      D.22566 = (int) D.22565;
      D.22582 = D.22566 & 1;
      if (D.22582 != 0) goto <D.22583>; else goto <D.22584>;
      <D.22583>:
      D.22551 = 0;
      return D.22551;
      <D.22584>:
      D.22545 = caller->klass;
      D.22546 = D.22545->image;
      assembly = mono_image_get_assembly (D.22546);
      D.22585 = mono_declsec_is_assembly_fulltrust (domain, assembly);
      if (D.22585 != 0) goto <D.22586>; else goto <D.22587>;
      <D.22586>:
      D.22551 = 0;
      return D.22551;
      <D.22587>:
      D.22551 = 1;
      return D.22551;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_declsec_linkdemand_standard (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * callee)
{
  unsigned char D.22590;
  struct MonoClass * D.22593;
  struct MonoImage * D.22594;
  struct MonoMethod * D.22595;
  gboolean D.22596;
  void * D.22597;
  unsigned char D.22598;
  _Bool D.22599;
  struct MonoDeclSecurityActions linkclass;
  struct MonoDeclSecurityActions linkmethod;

  try
    {
      InterlockedIncrement (&mono_jit_stats.cas_linkdemand);
      D.22590 = mono_declsec_get_linkdemands (callee, &linkclass, &linkmethod);
      if (D.22590 != 0) goto <D.22591>; else goto <D.22592>;
      <D.22591>:
      {
        struct MonoAssembly * assembly;
        struct MonoReflectionAssembly * refass;
        struct MonoSecurityManager * secman;
        struct MonoObject * res;
        void * args[3];

        try
          {
            D.22593 = caller->klass;
            D.22594 = D.22593->image;
            assembly = mono_image_get_assembly (D.22594);
            refass = mono_assembly_get_object (domain, assembly);
            secman = mono_security_manager_get_methods ();
            args[0] = refass;
            args[1] = &linkclass;
            args[2] = &linkmethod;
            D.22595 = secman->linkdemand;
            res = mono_runtime_invoke (D.22595, 0B, &args, 0B);
            D.22597 = mono_object_unbox (res);
            D.22598 = MEM[(MonoBoolean *)D.22597];
            D.22599 = D.22598 == 0;
            D.22596 = (gboolean) D.22599;
            return D.22596;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.22592>:
      D.22596 = 0;
      return D.22596;
    }
  finally
    {
      linkclass = {CLOBBER};
      linkmethod = {CLOBBER};
    }
}