mono_method_has_declsec (struct MonoMethod * method)
{
  unsigned char D.24373;
  unsigned char D.24374;
  _Bool D.24375;
  _Bool D.24376;
  _Bool D.24377;
  MonoBoolean D.24382;
  unsigned char D.24384;
  struct MonoClass * D.24389;
  unsigned int D.24390;
  unsigned int D.24391;
  short unsigned int D.24393;
  int D.24394;
  int D.24395;
  int D.24302;
  int iftmp.0;
  int D.24301;
  const char[7] * D.24399;
  unsigned char D.24400;
  int D.24401;
  unsigned char D.24402;
  int D.24403;
  _Bool D.24404;
  _Bool D.24405;
  _Bool D.24406;
  const unsigned char * D.24409;
  unsigned char D.24410;
  int D.24411;
  const unsigned char * D.24412;
  unsigned char D.24413;
  int D.24414;
  _Bool D.24415;
  _Bool D.24416;
  const unsigned char * D.24419;
  unsigned char D.24420;
  int D.24421;
  const unsigned char * D.24422;
  unsigned char D.24423;
  int D.24424;
  _Bool D.24425;
  _Bool D.24426;
  const unsigned char * D.24429;
  unsigned char D.24430;
  int D.24431;
  const unsigned char * D.24432;
  unsigned char D.24433;
  int D.24434;
  const char * D.24436;

  InterlockedIncrement (&mono_jit_stats.cas_declsec_check);
  D.24373 = BIT_FIELD_REF <*method, 8, 160>;
  D.24374 = D.24373 & 124;
  D.24375 = D.24374 == 24;
  D.24376 = D.24374 == 28;
  D.24377 = D.24375 | D.24376;
  if (D.24377 != 0) goto <D.24378>; else goto <D.24379>;
  <D.24378>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.24380>; else goto <D.24381>;
  <D.24380>:
  D.24382 = 0;
  return D.24382;
  <D.24381>:
  goto <D.24383>;
  <D.24379>:
  D.24373 = BIT_FIELD_REF <*method, 8, 160>;
  D.24384 = D.24373 & 124;
  if (D.24384 != 0) goto <D.24385>; else goto <D.24386>;
  <D.24385>:
  D.24382 = 0;
  return D.24382;
  <D.24386>:
  <D.24383>:
  D.24389 = method->klass;
  D.24390 = D.24389->flags;
  D.24391 = D.24390 & 262144;
  if (D.24391 != 0) goto <D.24387>; else goto <D.24392>;
  <D.24392>:
  D.24393 = method->flags;
  D.24394 = (int) D.24393;
  D.24395 = D.24394 & 16384;
  if (D.24395 != 0) goto <D.24387>; else goto <D.24388>;
  <D.24387>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.24399 = ".cctor";
      D.24400 = MEM[(const unsigned char *)D.24399];
      D.24401 = (int) D.24400;
      D.24402 = *__s2;
      D.24403 = (int) D.24402;
      __result = D.24401 - D.24403;
      {
        D.24404 = __s2_len != 0;
        D.24405 = __result == 0;
        D.24406 = D.24404 & D.24405;
        if (D.24406 != 0) goto <D.24407>; else goto <D.24408>;
        <D.24407>:
        D.24409 = &MEM[(void *)".cctor" + 1B];
        D.24410 = *D.24409;
        D.24411 = (int) D.24410;
        D.24412 = __s2 + 1;
        D.24413 = *D.24412;
        D.24414 = (int) D.24413;
        __result = D.24411 - D.24414;
        D.24415 = __s2_len > 1;
        D.24405 = __result == 0;
        D.24416 = D.24415 & D.24405;
        if (D.24416 != 0) goto <D.24417>; else goto <D.24418>;
        <D.24417>:
        D.24419 = &MEM[(void *)".cctor" + 2B];
        D.24420 = *D.24419;
        D.24421 = (int) D.24420;
        D.24422 = __s2 + 2;
        D.24423 = *D.24422;
        D.24424 = (int) D.24423;
        __result = D.24421 - D.24424;
        D.24425 = __s2_len > 2;
        D.24405 = __result == 0;
        D.24426 = D.24425 & D.24405;
        if (D.24426 != 0) goto <D.24427>; else goto <D.24428>;
        <D.24427>:
        D.24429 = &MEM[(void *)".cctor" + 3B];
        D.24430 = *D.24429;
        D.24431 = (int) D.24430;
        D.24432 = __s2 + 3;
        D.24433 = *D.24432;
        D.24434 = (int) D.24433;
        __result = D.24431 - D.24434;
        <D.24428>:
        <D.24418>:
        <D.24408>:
      }
      D.24301 = __result;
    }
    iftmp.0 = -D.24301;
    goto <D.24435>;
    <D.24398>:
    D.24436 = method->name;
    iftmp.0 = __builtin_strcmp (D.24436, ".cctor");
    <D.24435>:
    D.24302 = iftmp.0;
  }
  if (D.24302 != 0) goto <D.24437>; else goto <D.24438>;
  <D.24437>:
  D.24382 = 1;
  return D.24382;
  <D.24438>:
  <D.24388>:
  D.24382 = 0;
  return D.24382;
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.24440;
  unsigned int D.24441;

  D.24441 = __sync_add_and_fetch_4 (val, 1);
  D.24440 = (gint32) D.24441;
  return D.24440;
}


mono_declsec_cache_stack_modifiers (struct MonoJitInfo * jinfo)
{
  unsigned int D.24445;
  _Bool D.24446;
  <unnamed-signed:1> D.24447;
  unsigned int D.24448;
  _Bool D.24449;
  <unnamed-signed:1> D.24450;
  unsigned int D.24451;
  _Bool D.24452;
  <unnamed-signed:1> D.24453;
  struct MonoClass * D.24454;
  struct MonoMethodCasInfo * info;
  struct MonoMethod * method;
  guint32 flags;

  info = mono_jit_info_get_cas_info (jinfo);
  if (info == 0B) goto <D.24443>; else goto <D.24444>;
  <D.24443>:
  return;
  <D.24444>:
  method = jinfo_get_method (jinfo);
  flags = mono_declsec_flags_from_method (method);
  D.24445 = flags & 4;
  D.24446 = D.24445 != 0;
  D.24447 = (<unnamed-signed:1>) D.24446;
  info->cas_method_assert = D.24447;
  D.24448 = flags & 8;
  D.24449 = D.24448 != 0;
  D.24450 = (<unnamed-signed:1>) D.24449;
  info->cas_method_deny = D.24450;
  D.24451 = flags & 16;
  D.24452 = D.24451 != 0;
  D.24453 = (<unnamed-signed:1>) D.24452;
  info->cas_method_permitonly = D.24453;
  D.24454 = method->klass;
  flags = mono_declsec_flags_from_class (D.24454);
  D.24445 = flags & 4;
  D.24446 = D.24445 != 0;
  D.24447 = (<unnamed-signed:1>) D.24446;
  info->cas_class_assert = D.24447;
  D.24448 = flags & 8;
  D.24449 = D.24448 != 0;
  D.24450 = (<unnamed-signed:1>) D.24449;
  info->cas_class_deny = D.24450;
  D.24451 = flags & 16;
  D.24452 = D.24451 != 0;
  D.24453 = (<unnamed-signed:1>) D.24452;
  info->cas_class_permitonly = D.24453;
}


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

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


mono_declsec_create_frame (struct MonoDomain * domain, struct MonoJitInfo * jinfo)
{
  struct MonoClass * D.24458;
  unsigned char D.24461;
  unsigned char D.24462;
  unsigned char D.24465;
  struct MonoReflectionMethod * * D.24468;
  struct MonoReflectionMethod * D.24469;
  struct MonoAppDomain * * D.24470;
  struct MonoAppDomain * D.24471;
  unsigned char D.24475;
  struct MonoDeclSecurityEntry * D.24477;
  unsigned char D.24480;
  struct MonoClass * D.24483;
  unsigned char D.24487;
  struct MonoDeclSecurityEntry * D.24489;
  unsigned char D.24492;
  unsigned char D.24498;
  struct MonoDeclSecurityEntry * D.24500;
  unsigned char D.24503;
  struct MonoSecurityFrame * D.24506;
  struct MonoSecurityFrame * frame;
  struct MonoMethodCasInfo * info;
  struct MonoMethod * method;

  D.24458 = mono_defaults.runtimesecurityframe_class;
  frame = mono_object_new (domain, D.24458);
  method = jinfo_get_method (jinfo);
  info = mono_jit_info_get_cas_info (jinfo);
  if (info != 0B) goto <D.24459>; else goto <D.24460>;
  <D.24459>:
  D.24461 = BIT_FIELD_REF <*info, 8, 0>;
  D.24462 = D.24461 & 1;
  if (D.24462 == 0) goto <D.24463>; else goto <D.24464>;
  <D.24463>:
  D.24465 = mono_method_has_declsec (method);
  if (D.24465 != 0) goto <D.24466>; else goto <D.24467>;
  <D.24466>:
  mono_declsec_cache_stack_modifiers (jinfo);
  <D.24467>:
  info->cas_inited = -1;
  <D.24464>:
  <D.24460>:
  D.24468 = &frame->method;
  D.24469 = mono_method_get_object (domain, method, 0B);
  mono_gc_wbarrier_set_field (frame, D.24468, D.24469);
  D.24470 = &frame->domain;
  D.24471 = domain->domain;
  mono_gc_wbarrier_set_field (frame, D.24470, D.24471);
  if (info != 0B) goto <D.24474>; else goto <D.24472>;
  <D.24474>:
  D.24461 = BIT_FIELD_REF <*info, 8, 0>;
  D.24475 = D.24461 & 16;
  if (D.24475 != 0) goto <D.24476>; else goto <D.24472>;
  <D.24476>:
  D.24477 = &frame->assert;
  mono_declsec_get_method_action (method, 3, D.24477);
  goto <D.24473>;
  <D.24472>:
  if (info != 0B) goto <D.24478>; else goto <D.24479>;
  <D.24478>:
  D.24461 = BIT_FIELD_REF <*info, 8, 0>;
  D.24480 = D.24461 & 2;
  if (D.24480 != 0) goto <D.24481>; else goto <D.24482>;
  <D.24481>:
  D.24483 = method->klass;
  D.24477 = &frame->assert;
  mono_declsec_get_class_action (D.24483, 3, D.24477);
  <D.24482>:
  <D.24479>:
  <D.24473>:
  if (info != 0B) goto <D.24486>; else goto <D.24484>;
  <D.24486>:
  D.24461 = BIT_FIELD_REF <*info, 8, 0>;
  D.24487 = D.24461 & 32;
  if (D.24487 != 0) goto <D.24488>; else goto <D.24484>;
  <D.24488>:
  D.24489 = &frame->deny;
  mono_declsec_get_method_action (method, 4, D.24489);
  goto <D.24485>;
  <D.24484>:
  if (info != 0B) goto <D.24490>; else goto <D.24491>;
  <D.24490>:
  D.24461 = BIT_FIELD_REF <*info, 8, 0>;
  D.24492 = D.24461 & 4;
  if (D.24492 != 0) goto <D.24493>; else goto <D.24494>;
  <D.24493>:
  D.24483 = method->klass;
  D.24489 = &frame->deny;
  mono_declsec_get_class_action (D.24483, 4, D.24489);
  <D.24494>:
  <D.24491>:
  <D.24485>:
  if (info != 0B) goto <D.24497>; else goto <D.24495>;
  <D.24497>:
  D.24461 = BIT_FIELD_REF <*info, 8, 0>;
  D.24498 = D.24461 & 64;
  if (D.24498 != 0) goto <D.24499>; else goto <D.24495>;
  <D.24499>:
  D.24500 = &frame->permitonly;
  mono_declsec_get_method_action (method, 5, D.24500);
  goto <D.24496>;
  <D.24495>:
  if (info != 0B) goto <D.24501>; else goto <D.24502>;
  <D.24501>:
  D.24461 = BIT_FIELD_REF <*info, 8, 0>;
  D.24503 = D.24461 & 8;
  if (D.24503 != 0) goto <D.24504>; else goto <D.24505>;
  <D.24504>:
  D.24483 = method->klass;
  D.24500 = &frame->permitonly;
  mono_declsec_get_class_action (D.24483, 5, D.24500);
  <D.24505>:
  <D.24502>:
  <D.24496>:
  D.24506 = frame;
  return D.24506;
}


mono_declsec_linkdemand (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoClass * D.24508;
  struct MonoImage * D.24509;
  struct MonoImage * D.24510;
  struct MonoClass * D.24513;
  struct MonoImage * D.24514;
  guint32 D.24517;
  short unsigned int D.24518;
  int D.24519;
  int D.24520;
  int D.24523;
  short unsigned int D.24527;
  int D.24528;
  int D.24529;
  int D.24532;
  int D.24537;
  unsigned char D.24542;
  int D.24545;
  guint32 violation;

  violation = 0;
  D.24508 = caller->klass;
  D.24509 = D.24508->image;
  D.24510 = mono_defaults.corlib;
  if (D.24509 == D.24510) goto <D.24511>; else goto <D.24512>;
  <D.24511>:
  D.24513 = callee->klass;
  D.24514 = D.24513->image;
  D.24510 = mono_defaults.corlib;
  if (D.24514 == D.24510) goto <D.24515>; else goto <D.24516>;
  <D.24515>:
  D.24517 = violation;
  return D.24517;
  <D.24516>:
  <D.24512>:
  D.24518 = callee->iflags;
  D.24519 = (int) D.24518;
  D.24520 = D.24519 & 4096;
  if (D.24520 != 0) goto <D.24521>; else goto <D.24522>;
  <D.24521>:
  D.24523 = mono_declsec_linkdemand_icall (domain, caller, callee);
  if (D.24523 != 0) goto <D.24524>; else goto <D.24525>;
  <D.24524>:
  violation = 4;
  <D.24525>:
  goto <D.24526>;
  <D.24522>:
  D.24527 = callee->flags;
  D.24528 = (int) D.24527;
  D.24529 = D.24528 & 8192;
  if (D.24529 != 0) goto <D.24530>; else goto <D.24531>;
  <D.24530>:
  D.24532 = mono_declsec_linkdemand_pinvoke (domain, caller, callee);
  if (D.24532 != 0) goto <D.24533>; else goto <D.24534>;
  <D.24533>:
  violation = 8;
  <D.24534>:
  <D.24531>:
  <D.24526>:
  if (violation == 0) goto <D.24535>; else goto <D.24536>;
  <D.24535>:
  D.24537 = mono_declsec_linkdemand_aptc (domain, caller, callee);
  if (D.24537 != 0) goto <D.24538>; else goto <D.24539>;
  <D.24538>:
  violation = 2;
  <D.24539>:
  <D.24536>:
  if (violation == 0) goto <D.24540>; else goto <D.24541>;
  <D.24540>:
  D.24542 = mono_method_has_declsec (callee);
  if (D.24542 != 0) goto <D.24543>; else goto <D.24544>;
  <D.24543>:
  D.24545 = mono_declsec_linkdemand_standard (domain, caller, callee);
  if (D.24545 != 0) goto <D.24546>; else goto <D.24547>;
  <D.24546>:
  violation = 1;
  <D.24547>:
  <D.24544>:
  <D.24541>:
  D.24517 = violation;
  return D.24517;
}


mono_declsec_linkdemand_icall (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * icall)
{
  struct MonoClass * D.24549;
  struct MonoImage * D.24550;
  <unnamed-unsigned:2> D.24551;
  int D.24552;
  int D.24553;
  <unnamed-unsigned:2> iftmp.1;
  unsigned int size.2;
  int size.3;
  int D.24559;
  int D.24563;
  gboolean D.24566;
  struct MonoClass * D.24567;
  struct MonoImage * D.24568;
  int D.24569;
  _Bool D.24570;
  struct MonoAssembly * assembly;

  InterlockedIncrement (&mono_jit_stats.cas_linkdemand_icall);
  D.24549 = icall->klass;
  D.24550 = D.24549->image;
  assembly = mono_image_get_assembly (D.24550);
  D.24551 = assembly->ecma;
  D.24552 = (int) D.24551;
  D.24553 = D.24552 & 2;
  if (D.24553 == 0) goto <D.24554>; else goto <D.24555>;
  <D.24554>:
  {
    guint32 size;
    const char * pk;

    try
      {
        size = 0;
        D.24549 = icall->klass;
        D.24550 = D.24549->image;
        pk = mono_image_get_public_key (D.24550, &size);
        size.2 = size;
        size.3 = (int) size.2;
        D.24559 = mono_is_ecma_key (pk, size.3);
        if (D.24559 != 0) goto <D.24560>; else goto <D.24561>;
        <D.24560>:
        iftmp.1 = 3;
        goto <D.24562>;
        <D.24561>:
        iftmp.1 = 2;
        <D.24562>:
        assembly->ecma = iftmp.1;
      }
    finally
      {
        size = {CLOBBER};
      }
  }
  <D.24555>:
  D.24551 = assembly->ecma;
  D.24552 = (int) D.24551;
  D.24563 = D.24552 & 1;
  if (D.24563 != 0) goto <D.24564>; else goto <D.24565>;
  <D.24564>:
  D.24566 = 0;
  return D.24566;
  <D.24565>:
  D.24567 = caller->klass;
  D.24568 = D.24567->image;
  assembly = mono_image_get_assembly (D.24568);
  D.24569 = mono_declsec_is_assembly_fulltrust (domain, assembly);
  D.24570 = D.24569 == 0;
  D.24566 = (gboolean) D.24570;
  return D.24566;
}


mono_declsec_is_assembly_fulltrust (struct MonoDomain * domain, struct MonoAssembly * assembly)
{
  <unnamed-unsigned:2> D.24572;
  int D.24573;
  int D.24574;
  _Bool D.24577;
  _Bool D.24578;
  _Bool D.24579;
  struct MonoMethod * D.24582;
  void * D.24583;
  unsigned char D.24584;
  gboolean D.24587;
  int D.24588;

  D.24572 = assembly->fulltrust;
  D.24573 = (int) D.24572;
  D.24574 = D.24573 & 2;
  if (D.24574 == 0) goto <D.24575>; else goto <D.24576>;
  <D.24575>:
  {
    struct MonoReflectionAssembly * refass;
    struct MonoSecurityManager * secman;

    refass = mono_assembly_get_object (domain, assembly);
    secman = mono_security_manager_get_methods ();
    D.24577 = secman != 0B;
    D.24578 = refass != 0B;
    D.24579 = D.24577 & D.24578;
    if (D.24579 != 0) goto <D.24580>; else goto <D.24581>;
    <D.24580>:
    {
      struct MonoObject * res;
      void * args[1];

      try
        {
          args[0] = refass;
          D.24582 = secman->linkdemandfulltrust;
          res = mono_runtime_invoke (D.24582, 0B, &args, 0B);
          D.24583 = mono_object_unbox (res);
          D.24584 = MEM[(MonoBoolean *)D.24583];
          if (D.24584 != 0) goto <D.24585>; else goto <D.24586>;
          <D.24585>:
          assembly->fulltrust = 3;
          D.24587 = 1;
          return D.24587;
          <D.24586>:
        }
      finally
        {
          args = {CLOBBER};
        }
    }
    <D.24581>:
    assembly->fulltrust = 2;
    D.24587 = 0;
    return D.24587;
  }
  <D.24576>:
  D.24572 = assembly->fulltrust;
  D.24588 = (int) D.24572;
  D.24587 = D.24588 & 1;
  return D.24587;
}


mono_declsec_linkdemand_pinvoke (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * native)
{
  struct MonoClass * D.24592;
  struct MonoImage * D.24593;
  <unnamed-unsigned:2> D.24594;
  int D.24595;
  int D.24596;
  <unnamed-unsigned:2> D.24599;
  unsigned int D.24600;
  unsigned int D.24601;
  gboolean D.24604;
  _Bool D.24605;
  _Bool D.24606;
  _Bool D.24607;
  struct MonoMethod * D.24610;
  void * D.24611;
  unsigned char D.24612;
  int D.24615;
  struct MonoAssembly * assembly;

  D.24592 = caller->klass;
  D.24593 = D.24592->image;
  assembly = mono_image_get_assembly (D.24593);
  InterlockedIncrement (&mono_jit_stats.cas_linkdemand_pinvoke);
  D.24594 = assembly->unmanaged;
  D.24595 = (int) D.24594;
  D.24596 = D.24595 & 2;
  if (D.24596 == 0) goto <D.24597>; else goto <D.24598>;
  <D.24597>:
  D.24599 = assembly->fulltrust;
  D.24600 = (unsigned int) D.24599;
  D.24601 = D.24600 & 3;
  if (D.24601 == 3) goto <D.24602>; else goto <D.24603>;
  <D.24602>:
  assembly->unmanaged = 3;
  D.24604 = 0;
  return D.24604;
  <D.24603>:
  {
    struct MonoReflectionAssembly * refass;
    struct MonoSecurityManager * secman;

    refass = mono_assembly_get_object (domain, assembly);
    secman = mono_security_manager_get_methods ();
    D.24605 = secman != 0B;
    D.24606 = refass != 0B;
    D.24607 = D.24605 & D.24606;
    if (D.24607 != 0) goto <D.24608>; else goto <D.24609>;
    <D.24608>:
    {
      struct MonoObject * res;
      void * args[1];

      try
        {
          args[0] = refass;
          D.24610 = secman->linkdemandunmanaged;
          res = mono_runtime_invoke (D.24610, 0B, &args, 0B);
          D.24611 = mono_object_unbox (res);
          D.24612 = MEM[(MonoBoolean *)D.24611];
          if (D.24612 != 0) goto <D.24613>; else goto <D.24614>;
          <D.24613>:
          assembly->unmanaged = 3;
          D.24604 = 0;
          return D.24604;
          <D.24614>:
        }
      finally
        {
          args = {CLOBBER};
        }
    }
    <D.24609>:
  }
  assembly->unmanaged = 2;
  <D.24598>:
  D.24594 = assembly->unmanaged;
  D.24595 = (int) D.24594;
  D.24615 = D.24595 & 1;
  if (D.24615 != 0) goto <D.24616>; else goto <D.24617>;
  <D.24616>:
  D.24604 = 0;
  return D.24604;
  <D.24617>:
  D.24604 = 1;
  return D.24604;
}


mono_declsec_linkdemand_aptc (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoClass * D.24621;
  struct MonoImage * D.24622;
  struct MonoClass * D.24623;
  struct MonoImage * D.24624;
  gboolean D.24627;
  unsigned int D.24630;
  unsigned int D.24631;
  short unsigned int D.24633;
  int D.24634;
  int D.24635;
  const char * D.24638;
  unsigned int size.4;
  <unnamed-unsigned:2> D.24641;
  int D.24642;
  int D.24643;
  _Bool D.24646;
  _Bool D.24647;
  _Bool D.24648;
  struct MonoClass * D.24651;
  <unnamed-unsigned:2> iftmp.5;
  int D.24658;
  int D.24661;
  struct MonoSecurityManager * secman;
  struct MonoAssembly * assembly;
  guint32 size;

  try
    {
      secman = 0B;
      size = 0;
      InterlockedIncrement (&mono_jit_stats.cas_linkdemand_aptc);
      D.24621 = caller->klass;
      D.24622 = D.24621->image;
      D.24623 = callee->klass;
      D.24624 = D.24623->image;
      if (D.24622 == D.24624) goto <D.24625>; else goto <D.24626>;
      <D.24625>:
      D.24627 = 0;
      return D.24627;
      <D.24626>:
      D.24623 = callee->klass;
      D.24630 = D.24623->flags;
      D.24631 = D.24630 & 1;
      if (D.24631 == 0) goto <D.24628>; else goto <D.24632>;
      <D.24632>:
      D.24633 = callee->flags;
      D.24634 = (int) D.24633;
      D.24635 = D.24634 & 6;
      if (D.24635 == 0) goto <D.24628>; else goto <D.24629>;
      <D.24628>:
      D.24627 = 0;
      return D.24627;
      <D.24629>:
      D.24623 = callee->klass;
      D.24624 = D.24623->image;
      D.24638 = mono_image_get_public_key (D.24624, &size);
      if (D.24638 == 0B) goto <D.24636>; else goto <D.24639>;
      <D.24639>:
      size.4 = size;
      if (size.4 <= 15) goto <D.24636>; else goto <D.24637>;
      <D.24636>:
      D.24627 = 0;
      return D.24627;
      <D.24637>:
      D.24623 = callee->klass;
      D.24624 = D.24623->image;
      assembly = mono_image_get_assembly (D.24624);
      D.24641 = assembly->aptc;
      D.24642 = (int) D.24641;
      D.24643 = D.24642 & 2;
      if (D.24643 == 0) goto <D.24644>; else goto <D.24645>;
      <D.24644>:
      {
        struct MonoCustomAttrInfo * cinfo;
        gboolean result;

        cinfo = mono_custom_attrs_from_assembly (assembly);
        result = 0;
        secman = mono_security_manager_get_methods ();
        D.24646 = secman != 0B;
        D.24647 = cinfo != 0B;
        D.24648 = D.24646 & D.24647;
        if (D.24648 != 0) goto <D.24649>; else goto <D.24650>;
        <D.24649>:
        D.24651 = secman->allowpartiallytrustedcallers;
        result = mono_custom_attrs_has_attr (cinfo, D.24651);
        <D.24650>:
        if (cinfo != 0B) goto <D.24652>; else goto <D.24653>;
        <D.24652>:
        mono_custom_attrs_free (cinfo);
        <D.24653>:
        if (result != 0) goto <D.24655>; else goto <D.24656>;
        <D.24655>:
        iftmp.5 = 3;
        goto <D.24657>;
        <D.24656>:
        iftmp.5 = 2;
        <D.24657>:
        assembly->aptc = iftmp.5;
      }
      <D.24645>:
      D.24641 = assembly->aptc;
      D.24642 = (int) D.24641;
      D.24658 = D.24642 & 1;
      if (D.24658 != 0) goto <D.24659>; else goto <D.24660>;
      <D.24659>:
      D.24627 = 0;
      return D.24627;
      <D.24660>:
      D.24621 = caller->klass;
      D.24622 = D.24621->image;
      assembly = mono_image_get_assembly (D.24622);
      D.24661 = mono_declsec_is_assembly_fulltrust (domain, assembly);
      if (D.24661 != 0) goto <D.24662>; else goto <D.24663>;
      <D.24662>:
      D.24627 = 0;
      return D.24627;
      <D.24663>:
      D.24627 = 1;
      return D.24627;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_declsec_linkdemand_standard (struct MonoDomain * domain, struct MonoMethod * caller, struct MonoMethod * callee)
{
  unsigned char D.24666;
  struct MonoClass * D.24669;
  struct MonoImage * D.24670;
  struct MonoMethod * D.24671;
  gboolean D.24672;
  void * D.24673;
  unsigned char D.24674;
  _Bool D.24675;
  struct MonoDeclSecurityActions linkclass;
  struct MonoDeclSecurityActions linkmethod;

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

        try
          {
            D.24669 = caller->klass;
            D.24670 = D.24669->image;
            assembly = mono_image_get_assembly (D.24670);
            refass = mono_assembly_get_object (domain, assembly);
            secman = mono_security_manager_get_methods ();
            args[0] = refass;
            args[1] = &linkclass;
            args[2] = &linkmethod;
            D.24671 = secman->linkdemand;
            res = mono_runtime_invoke (D.24671, 0B, &args, 0B);
            D.24673 = mono_object_unbox (res);
            D.24674 = MEM[(MonoBoolean *)D.24673];
            D.24675 = D.24674 == 0;
            D.24672 = (gboolean) D.24675;
            return D.24672;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.24668>:
      D.24672 = 0;
      return D.24672;
    }
  finally
    {
      linkclass = {CLOBBER};
      linkmethod = {CLOBBER};
    }
}