mono_security_set_mode (MonoSecurityMode mode)
{
  mono_security_mode = mode;
}


mono_security_get_mode ()
{
  MonoSecurityMode D.16667;

  D.16667 = mono_security_mode;
  return D.16667;
}


mono_activate_security_manager ()
{
  mono_security_manager_activated = 1;
}


mono_is_security_manager_active ()
{
  gboolean D.16669;
  unsigned char mono_security_manager_activated.0;

  mono_security_manager_activated.0 = mono_security_manager_activated;
  D.16669 = (gboolean) mono_security_manager_activated.0;
  return D.16669;
}


mono_security_manager_get_methods ()
{
  struct MonoClass * D.16672;
  struct MonoSecurityManager * D.16675;
  struct MonoImage * D.16676;
  struct MonoClass * D.16677;
  _Bool D.16678;
  long int D.16679;
  long int D.16680;
  unsigned char D.16683;
  unsigned char D.16684;
  struct MonoMethod * D.16687;
  struct MonoMethod * D.16688;
  _Bool D.16689;
  long int D.16690;
  long int D.16691;
  struct MonoMethod * D.16694;
  struct MonoMethod * D.16695;
  _Bool D.16696;
  long int D.16697;
  long int D.16698;
  struct MonoMethod * D.16701;
  struct MonoMethod * D.16702;
  _Bool D.16703;
  long int D.16704;
  long int D.16705;
  struct MonoMethod * D.16708;
  struct MonoMethod * D.16709;
  _Bool D.16710;
  long int D.16711;
  long int D.16712;
  struct MonoMethod * D.16715;
  struct MonoMethod * D.16716;
  _Bool D.16717;
  long int D.16718;
  long int D.16719;
  struct MonoMethod * D.16722;
  struct MonoMethod * D.16723;
  _Bool D.16724;
  long int D.16725;
  long int D.16726;
  struct MonoMethod * D.16729;
  struct MonoMethod * D.16730;
  _Bool D.16731;
  long int D.16732;
  long int D.16733;
  struct MonoMethod * D.16736;
  struct MonoMethod * D.16737;
  _Bool D.16738;
  long int D.16739;
  long int D.16740;
  struct MonoMethod * D.16743;
  struct MonoMethod * D.16744;
  _Bool D.16745;
  long int D.16746;
  long int D.16747;
  struct MonoClass * D.16750;
  struct MonoClass * D.16751;
  _Bool D.16752;
  long int D.16753;
  long int D.16754;
  struct MonoClass * D.16757;
  struct MonoClass * D.16758;
  _Bool D.16759;
  long int D.16760;
  long int D.16761;

  D.16672 = secman.securitymanager;
  if (D.16672 != 0B) goto <D.16673>; else goto <D.16674>;
  <D.16673>:
  D.16675 = &secman;
  return D.16675;
  <D.16674>:
  D.16676 = mono_defaults.corlib;
  D.16677 = mono_class_from_name (D.16676, "System.Security", "SecurityManager");
  secman.securitymanager = D.16677;
  D.16672 = secman.securitymanager;
  D.16678 = D.16672 == 0B;
  D.16679 = (long int) D.16678;
  D.16680 = __builtin_expect (D.16679, 0);
  if (D.16680 != 0) goto <D.16681>; else goto <D.16682>;
  <D.16681>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 59, "secman.securitymanager");
  <D.16682>:
  D.16672 = secman.securitymanager;
  D.16683 = BIT_FIELD_REF <*D.16672, 8, 160>;
  D.16684 = D.16683 & 1;
  if (D.16684 == 0) goto <D.16685>; else goto <D.16686>;
  <D.16685>:
  D.16672 = secman.securitymanager;
  mono_class_init (D.16672);
  <D.16686>:
  D.16672 = secman.securitymanager;
  D.16687 = mono_class_get_method_from_name (D.16672, "InternalDemand", 2);
  secman.demand = D.16687;
  D.16688 = secman.demand;
  D.16689 = D.16688 == 0B;
  D.16690 = (long int) D.16689;
  D.16691 = __builtin_expect (D.16690, 0);
  if (D.16691 != 0) goto <D.16692>; else goto <D.16693>;
  <D.16692>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 65, "secman.demand");
  <D.16693>:
  D.16672 = secman.securitymanager;
  D.16694 = mono_class_get_method_from_name (D.16672, "InternalDemandChoice", 2);
  secman.demandchoice = D.16694;
  D.16695 = secman.demandchoice;
  D.16696 = D.16695 == 0B;
  D.16697 = (long int) D.16696;
  D.16698 = __builtin_expect (D.16697, 0);
  if (D.16698 != 0) goto <D.16699>; else goto <D.16700>;
  <D.16699>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 69, "secman.demandchoice");
  <D.16700>:
  D.16672 = secman.securitymanager;
  D.16701 = mono_class_get_method_from_name (D.16672, "DemandUnmanaged", 0);
  secman.demandunmanaged = D.16701;
  D.16702 = secman.demandunmanaged;
  D.16703 = D.16702 == 0B;
  D.16704 = (long int) D.16703;
  D.16705 = __builtin_expect (D.16704, 0);
  if (D.16705 != 0) goto <D.16706>; else goto <D.16707>;
  <D.16706>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 73, "secman.demandunmanaged");
  <D.16707>:
  D.16672 = secman.securitymanager;
  D.16708 = mono_class_get_method_from_name (D.16672, "InheritanceDemand", 3);
  secman.inheritancedemand = D.16708;
  D.16709 = secman.inheritancedemand;
  D.16710 = D.16709 == 0B;
  D.16711 = (long int) D.16710;
  D.16712 = __builtin_expect (D.16711, 0);
  if (D.16712 != 0) goto <D.16713>; else goto <D.16714>;
  <D.16713>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 77, "secman.inheritancedemand");
  <D.16714>:
  D.16672 = secman.securitymanager;
  D.16715 = mono_class_get_method_from_name (D.16672, "InheritanceDemandSecurityException", 4);
  secman.inheritsecurityexception = D.16715;
  D.16716 = secman.inheritsecurityexception;
  D.16717 = D.16716 == 0B;
  D.16718 = (long int) D.16717;
  D.16719 = __builtin_expect (D.16718, 0);
  if (D.16719 != 0) goto <D.16720>; else goto <D.16721>;
  <D.16720>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 81, "secman.inheritsecurityexception");
  <D.16721>:
  D.16672 = secman.securitymanager;
  D.16722 = mono_class_get_method_from_name (D.16672, "LinkDemand", 3);
  secman.linkdemand = D.16722;
  D.16723 = secman.linkdemand;
  D.16724 = D.16723 == 0B;
  D.16725 = (long int) D.16724;
  D.16726 = __builtin_expect (D.16725, 0);
  if (D.16726 != 0) goto <D.16727>; else goto <D.16728>;
  <D.16727>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 85, "secman.linkdemand");
  <D.16728>:
  D.16672 = secman.securitymanager;
  D.16729 = mono_class_get_method_from_name (D.16672, "LinkDemandUnmanaged", 1);
  secman.linkdemandunmanaged = D.16729;
  D.16730 = secman.linkdemandunmanaged;
  D.16731 = D.16730 == 0B;
  D.16732 = (long int) D.16731;
  D.16733 = __builtin_expect (D.16732, 0);
  if (D.16733 != 0) goto <D.16734>; else goto <D.16735>;
  <D.16734>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 89, "secman.linkdemandunmanaged");
  <D.16735>:
  D.16672 = secman.securitymanager;
  D.16736 = mono_class_get_method_from_name (D.16672, "LinkDemandFullTrust", 1);
  secman.linkdemandfulltrust = D.16736;
  D.16737 = secman.linkdemandfulltrust;
  D.16738 = D.16737 == 0B;
  D.16739 = (long int) D.16738;
  D.16740 = __builtin_expect (D.16739, 0);
  if (D.16740 != 0) goto <D.16741>; else goto <D.16742>;
  <D.16741>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 93, "secman.linkdemandfulltrust");
  <D.16742>:
  D.16672 = secman.securitymanager;
  D.16743 = mono_class_get_method_from_name (D.16672, "LinkDemandSecurityException", 2);
  secman.linkdemandsecurityexception = D.16743;
  D.16744 = secman.linkdemandsecurityexception;
  D.16745 = D.16744 == 0B;
  D.16746 = (long int) D.16745;
  D.16747 = __builtin_expect (D.16746, 0);
  if (D.16747 != 0) goto <D.16748>; else goto <D.16749>;
  <D.16748>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 97, "secman.linkdemandsecurityexception");
  <D.16749>:
  D.16676 = mono_defaults.corlib;
  D.16750 = mono_class_from_name (D.16676, "System.Security", "AllowPartiallyTrustedCallersAttribute");
  secman.allowpartiallytrustedcallers = D.16750;
  D.16751 = secman.allowpartiallytrustedcallers;
  D.16752 = D.16751 == 0B;
  D.16753 = (long int) D.16752;
  D.16754 = __builtin_expect (D.16753, 0);
  if (D.16754 != 0) goto <D.16755>; else goto <D.16756>;
  <D.16755>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 101, "secman.allowpartiallytrustedcallers");
  <D.16756>:
  D.16676 = mono_defaults.corlib;
  D.16757 = mono_class_from_name (D.16676, "System.Security", "SuppressUnmanagedCodeSecurityAttribute");
  secman.suppressunmanagedcodesecurity = D.16757;
  D.16758 = secman.suppressunmanagedcodesecurity;
  D.16759 = D.16758 == 0B;
  D.16760 = (long int) D.16759;
  D.16761 = __builtin_expect (D.16760, 0);
  if (D.16761 != 0) goto <D.16762>; else goto <D.16763>;
  <D.16762>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "security-manager.c", 105, "secman.suppressunmanagedcodesecurity");
  <D.16763>:
  D.16675 = &secman;
  return D.16675;
}


mono_secman_inheritancedemand_class (struct MonoClass * klass, struct MonoClass * parent)
{
  unsigned char D.16765;
  struct MonoImage * D.16768;
  struct MonoImage * D.16769;
  struct MonoImage * D.16772;
  unsigned char D.16775;
  int D.16778;
  struct MonoDeclSecurityActions demands;

  try
    {
      D.16765 = klass->exception_type;
      if (D.16765 != 0) goto <D.16766>; else goto <D.16767>;
      <D.16766>:
      return;
      <D.16767>:
      D.16768 = klass->image;
      D.16769 = mono_defaults.corlib;
      if (D.16768 == D.16769) goto <D.16770>; else goto <D.16771>;
      <D.16770>:
      D.16772 = parent->image;
      D.16769 = mono_defaults.corlib;
      if (D.16772 == D.16769) goto <D.16773>; else goto <D.16774>;
      <D.16773>:
      return;
      <D.16774>:
      <D.16771>:
      D.16775 = mono_declsec_get_inheritdemands_class (parent, &demands);
      if (D.16775 != 0) goto <D.16776>; else goto <D.16777>;
      <D.16776>:
      D.16778 = mono_secman_inheritance_check (klass, &demands);
      if (D.16778 == 0) goto <D.16779>; else goto <D.16780>;
      <D.16779>:
      mono_class_set_failure (klass, 2, 0B);
      <D.16780>:
      <D.16777>:
    }
  finally
    {
      demands = {CLOBBER};
    }
}


mono_secman_inheritance_check (struct MonoClass * klass, struct MonoDeclSecurityActions * demands)
{
  struct MonoImage * D.16784;
  struct MonoAppDomain * D.16785;
  struct MonoMethod * D.16786;
  gboolean D.16787;
  void * D.16788;
  unsigned char D.16789;
  struct MonoSecurityManager * secman;
  struct MonoDomain * domain;
  struct MonoAssembly * assembly;
  struct MonoReflectionAssembly * refass;
  struct MonoObject * res;
  void * args[3];

  try
    {
      secman = mono_security_manager_get_methods ();
      domain = mono_domain_get ();
      D.16784 = klass->image;
      assembly = mono_image_get_assembly (D.16784);
      refass = mono_assembly_get_object (domain, assembly);
      D.16785 = domain->domain;
      args[0] = D.16785;
      args[1] = refass;
      args[2] = demands;
      D.16786 = secman->inheritancedemand;
      res = mono_runtime_invoke (D.16786, 0B, &args, 0B);
      D.16788 = mono_object_unbox (res);
      D.16789 = MEM[(MonoBoolean *)D.16788];
      D.16787 = (gboolean) D.16789;
      return D.16787;
    }
  finally
    {
      args = {CLOBBER};
    }
}


mono_secman_inheritancedemand_method (struct MonoMethod * override, struct MonoMethod * base)
{
  struct MonoClass * D.16792;
  unsigned char D.16793;
  struct MonoImage * D.16796;
  struct MonoImage * D.16797;
  struct MonoClass * D.16800;
  struct MonoImage * D.16801;
  unsigned char D.16804;
  int D.16807;
  struct MonoDeclSecurityActions demands;

  try
    {
      D.16792 = override->klass;
      D.16793 = D.16792->exception_type;
      if (D.16793 != 0) goto <D.16794>; else goto <D.16795>;
      <D.16794>:
      return;
      <D.16795>:
      D.16792 = override->klass;
      D.16796 = D.16792->image;
      D.16797 = mono_defaults.corlib;
      if (D.16796 == D.16797) goto <D.16798>; else goto <D.16799>;
      <D.16798>:
      D.16800 = base->klass;
      D.16801 = D.16800->image;
      D.16797 = mono_defaults.corlib;
      if (D.16801 == D.16797) goto <D.16802>; else goto <D.16803>;
      <D.16802>:
      return;
      <D.16803>:
      <D.16799>:
      D.16804 = mono_declsec_get_inheritdemands_method (base, &demands);
      if (D.16804 != 0) goto <D.16805>; else goto <D.16806>;
      <D.16805>:
      D.16792 = override->klass;
      D.16807 = mono_secman_inheritance_check (D.16792, &demands);
      if (D.16807 == 0) goto <D.16808>; else goto <D.16809>;
      <D.16808>:
      D.16792 = override->klass;
      mono_class_set_failure (D.16792, 2, base);
      <D.16809>:
      <D.16806>:
    }
  finally
    {
      demands = {CLOBBER};
    }
}


mono_is_ecma_key (const char * publickey, int size)
{
  _Bool D.16815;
  _Bool D.16816;
  _Bool D.16817;
  const char * D.16819;
  char D.16820;
  gboolean D.16821;
  sizetype i.1;
  const char * D.16823;
  char D.16824;
  int i;

  D.16815 = publickey == 0B;
  D.16816 = size != 16;
  D.16817 = D.16815 | D.16816;
  if (D.16817 != 0) goto <D.16813>; else goto <D.16818>;
  <D.16818>:
  D.16819 = publickey + 8;
  D.16820 = *D.16819;
  if (D.16820 != 4) goto <D.16813>; else goto <D.16814>;
  <D.16813>:
  D.16821 = 0;
  return D.16821;
  <D.16814>:
  i = 0;
  goto <D.16642>;
  <D.16641>:
  i.1 = (sizetype) i;
  D.16823 = publickey + i.1;
  D.16824 = *D.16823;
  if (D.16824 != 0) goto <D.16825>; else goto <D.16826>;
  <D.16825>:
  if (i != 8) goto <D.16827>; else goto <D.16828>;
  <D.16827>:
  D.16821 = 0;
  return D.16821;
  <D.16828>:
  <D.16826>:
  i = i + 1;
  <D.16642>:
  if (i < size) goto <D.16641>; else goto <D.16643>;
  <D.16643>:
  D.16821 = 1;
  return D.16821;
}


mono_get_context_capture_method ()
{
  unsigned char mono_security_manager_activated.2;
  struct MonoImage * D.16833;
  struct MonoAssembly * D.16834;
  short unsigned int D.16835;
  struct MonoMethod * D.16838;
  struct MonoClass * D.16839;
  struct MonoMethod * method.3;
  struct MonoMethod * method.4;
  static struct MonoMethod * method = 0B;

  mono_security_manager_activated.2 = mono_security_manager_activated;
  if (mono_security_manager_activated.2 == 0) goto <D.16831>; else goto <D.16832>;
  <D.16831>:
  D.16833 = mono_defaults.corlib;
  D.16834 = mono_image_get_assembly (D.16833);
  D.16835 = D.16834->aname.major;
  if (D.16835 <= 1) goto <D.16836>; else goto <D.16837>;
  <D.16836>:
  D.16838 = 0B;
  return D.16838;
  <D.16837>:
  <D.16832>:
  D.16839 = mono_defaults.executioncontext_class;
  if (D.16839 != 0B) goto <D.16840>; else goto <D.16841>;
  <D.16840>:
  method.3 = method;
  if (method.3 == 0B) goto <D.16843>; else goto <D.16844>;
  <D.16843>:
  D.16839 = mono_defaults.executioncontext_class;
  mono_class_init (D.16839);
  D.16839 = mono_defaults.executioncontext_class;
  method.4 = mono_class_get_method_from_name (D.16839, "Capture", 0);
  method = method.4;
  <D.16844>:
  <D.16841>:
  D.16838 = method;
  return D.16838;
}


ves_icall_System_Security_SecurityManager_get_SecurityEnabled ()
{
  unsigned char mono_security_manager_activated.5;
  MonoBoolean D.16850;
  <unnamed type> D.16851;
  _Bool D.16852;

  mono_security_manager_activated.5 = mono_security_manager_activated;
  if (mono_security_manager_activated.5 == 0) goto <D.16848>; else goto <D.16849>;
  <D.16848>:
  D.16851 = mono_security_get_mode ();
  D.16852 = D.16851 == 1;
  D.16850 = (MonoBoolean) D.16852;
  return D.16850;
  <D.16849>:
  D.16850 = mono_security_manager_enabled;
  return D.16850;
}


ves_icall_System_Security_SecurityManager_set_SecurityEnabled (MonoBoolean value)
{
  unsigned char mono_security_manager_activated.6;

  mono_security_manager_activated.6 = mono_security_manager_activated;
  if (mono_security_manager_activated.6 != 0) goto <D.16855>; else goto <D.16856>;
  <D.16855>:
  mono_security_manager_enabled = value;
  <D.16856>:
}


ves_icall_System_Security_SecurityManager_get_CheckExecutionRights ()
{
  unsigned char mono_security_manager_activated.7;
  MonoBoolean D.16860;

  mono_security_manager_activated.7 = mono_security_manager_activated;
  if (mono_security_manager_activated.7 == 0) goto <D.16858>; else goto <D.16859>;
  <D.16858>:
  D.16860 = 0;
  return D.16860;
  <D.16859>:
  D.16860 = mono_security_manager_execution;
  return D.16860;
}


ves_icall_System_Security_SecurityManager_set_CheckExecutionRights (MonoBoolean value)
{
  unsigned char mono_security_manager_activated.8;

  mono_security_manager_activated.8 = mono_security_manager_activated;
  if (mono_security_manager_activated.8 != 0) goto <D.16863>; else goto <D.16864>;
  <D.16863>:
  mono_security_manager_execution = value;
  <D.16864>:
}


ves_icall_System_Security_SecurityManager_GetLinkDemandSecurity (struct MonoReflectionMethod * m, struct MonoDeclSecurityActions * kactions, struct MonoDeclSecurityActions * mactions)
{
  unsigned char D.16865;
  unsigned char D.16866;
  _Bool D.16867;
  _Bool D.16868;
  _Bool D.16869;
  struct MonoClass * D.16872;
  short unsigned int D.16875;
  int D.16876;
  int D.16877;
  unsigned int D.16879;
  unsigned int D.16880;
  MonoBoolean D.16881;
  struct MonoMethod * method;

  method = m->method;
  D.16865 = BIT_FIELD_REF <*method, 8, 160>;
  D.16866 = D.16865 & 124;
  D.16867 = D.16866 == 24;
  D.16868 = D.16866 == 28;
  D.16869 = D.16867 | D.16868;
  if (D.16869 != 0) goto <D.16870>; else goto <D.16871>;
  <D.16870>:
  method = mono_marshal_method_from_wrapper (method);
  <D.16871>:
  D.16872 = method->klass;
  mono_class_init (D.16872);
  D.16875 = method->flags;
  D.16876 = (int) D.16875;
  D.16877 = D.16876 & 16384;
  if (D.16877 != 0) goto <D.16873>; else goto <D.16878>;
  <D.16878>:
  D.16872 = method->klass;
  D.16879 = D.16872->flags;
  D.16880 = D.16879 & 262144;
  if (D.16880 != 0) goto <D.16873>; else goto <D.16874>;
  <D.16873>:
  memset (kactions, 0, 36);
  memset (mactions, 0, 36);
  D.16881 = mono_declsec_get_linkdemands (method, kactions, mactions);
  return D.16881;
  <D.16874>:
  D.16881 = 0;
  return D.16881;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.16885;
  int D.16890;
  void * D.16892;
  unsigned int D.16893;

  D.16885 = __builtin_constant_p (__len);
  if (D.16885 != 0) goto <D.16886>; else goto <D.16887>;
  <D.16886>:
  if (__len == 0) goto <D.16888>; else goto <D.16889>;
  <D.16888>:
  D.16890 = __builtin_constant_p (__ch);
  if (D.16890 == 0) goto <D.16883>; else goto <D.16891>;
  <D.16891>:
  if (__ch != 0) goto <D.16883>; else goto <D.16884>;
  <D.16883>:
  __warn_memset_zero_len ();
  D.16892 = __dest;
  return D.16892;
  <D.16884>:
  <D.16889>:
  <D.16887>:
  D.16893 = __builtin_object_size (__dest, 0);
  D.16892 = __builtin___memset_chk (__dest, __ch, __len, D.16893);
  return D.16892;
}