bool IReportMatchMembershipCondition.Check(Evidence evidence, out object usedEvidence)
 {
     usedEvidence = null;
     if (evidence != null)
     {
         ApplicationDirectory hostEvidence = evidence.GetHostEvidence<ApplicationDirectory>();
         Url url = evidence.GetHostEvidence<Url>();
         if ((hostEvidence != null) && (url != null))
         {
             string directory = hostEvidence.Directory;
             if ((directory != null) && (directory.Length > 1))
             {
                 if (directory[directory.Length - 1] == '/')
                 {
                     directory = directory + "*";
                 }
                 else
                 {
                     directory = directory + "/*";
                 }
                 URLString operand = new URLString(directory);
                 if (url.GetURLString().IsSubsetOf(operand))
                 {
                     usedEvidence = hostEvidence;
                     return true;
                 }
             }
         }
     }
     return false;
 }

 /// <include file='doc\URL.uex' path='docs/doc[@for="Url.Url"]/*' />
 public Url( String name )
 {
     if (name == null)
         throw new ArgumentNullException( "name" );
 
     m_url = new URLString( name );
 }

 /// <include file='doc\ApplicationDirectory.uex' path='docs/doc[@for="ApplicationDirectory.ApplicationDirectory"]/*' />
 public ApplicationDirectory( String name )
 {
     if (name == null)
         throw new ArgumentNullException( "name" );
 
     m_appDirectory = new URLString( name );
 }

 /// <include file='doc\URLIdentityPermission.uex' path='docs/doc[@for="UrlIdentityPermission.UrlIdentityPermission1"]/*' />
 public UrlIdentityPermission( String site )
 {
     if (site == null)
         throw new ArgumentNullException( "site" );
         
     m_url = new URLString( site );
 }

        internal Url( String name, bool parsed )
        {
            if (name == null)
                throw new ArgumentNullException( nameof(name) );
            Contract.EndContractBlock();

            m_url = new URLString( name, parsed );
        }

        public UrlMembershipCondition( String url )
        {
            if (url == null)
                throw new ArgumentNullException( "url" );

            // Parse the Url to check that it's valid.
            m_url = new URLString(url, false /* not parsed */, true /* parse eagerly */);
        }

        public Url( String name ) 
        {
            if (name == null)
                throw new ArgumentNullException( "name" );
            Contract.EndContractBlock(); 

            m_url = new URLString( name ); 
        } 

 private static SiteString ParseSiteFromUrl(string name)
 {
     URLString str = new URLString(name);
     if (string.Compare(str.Scheme, "file", StringComparison.OrdinalIgnoreCase) == 0)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidSite"));
     }
     return new SiteString(new URLString(name).Host);
 }

        public UrlMembershipCondition( String url )
        {
            if (url == null)
                throw new ArgumentNullException( "url" );
            Contract.EndContractBlock();

            // Parse the Url to check that it's valid.
            m_url = new URLString(url, false /* not parsed */, true /* parse eagerly */);

            if (m_url.IsRelativeFileUrl)
                throw new ArgumentException(Environment.GetResourceString("Argument_RelativeUrlMembershipCondition"), "url");
        }

        private void OnDeserialized(StreamingContext ctx)
        {
            // v2.0 and beyond XML case
            if (m_serializedPermission != null)
            {
                FromXml(SecurityElement.FromString(m_serializedPermission));
                m_serializedPermission = null;
            }
            else if (m_url != null) //v1.x case where we read the m_site value
            {
                m_unrestricted = false;
                m_urls = new URLString[1];
                m_urls[0] = m_url;
                m_url = null;
            }

        }

 public static bool CompareUrls(URLString url1, URLString url2)
 {
     if ((url1 == null) && (url2 == null))
     {
         return true;
     }
     if ((url1 == null) || (url2 == null))
     {
         return false;
     }
     url1.DoDeferredParse();
     url2.DoDeferredParse();
     URLString str = url1.SpecialNormalizeUrl();
     URLString str2 = url2.SpecialNormalizeUrl();
     if (string.Compare(str.m_protocol, str2.m_protocol, StringComparison.OrdinalIgnoreCase) != 0)
     {
         return false;
     }
     if (string.Compare(str.m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0)
     {
         if (!str.m_localSite.IsSubsetOf(str2.m_localSite) || !str2.m_localSite.IsSubsetOf(str.m_localSite))
         {
             return false;
         }
     }
     else
     {
         if (string.Compare(str.m_userpass, str2.m_userpass, StringComparison.Ordinal) != 0)
         {
             return false;
         }
         if (!str.m_siteString.IsSubsetOf(str2.m_siteString) || !str2.m_siteString.IsSubsetOf(str.m_siteString))
         {
             return false;
         }
         if (url1.m_port != url2.m_port)
         {
             return false;
         }
     }
     return (str.m_directory.IsSubsetOf(str2.m_directory) && str2.m_directory.IsSubsetOf(str.m_directory));
 }

        internal URLString SpecialNormalizeUrl() 
        { 
            // Under WinXP, file protocol urls can be mapped to
            // drives that aren't actually file protocol underneath 
            // due to drive mounting.  This code attempts to figure
            // out what a drive is mounted to and create the
            // url is maps to.
 
            DoDeferredParse();
            if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) != 0) 
            { 
                return this;
            } 
            else
            {
                String localSite = m_localSite.ToString();
 
                if (localSite.Length == 2 &&
                    (localSite[1] == '|' || 
                     localSite[1] == ':')) 
                {
                    String deviceName = null; 
                    GetDeviceName(localSite, JitHelpers.GetStringHandleOnStack(ref deviceName));

                    if (deviceName != null)
                    { 
                        if (deviceName.IndexOf( "://", StringComparison.Ordinal ) != -1)
                        { 
                            URLString u = new URLString( deviceName + "/" + this.m_directory.ToString() ); 
                            u.DoDeferredParse(); // Presumably the caller of SpecialNormalizeUrl wants a fully parsed URL
                            return u; 
                        }
                        else
                        {
                            URLString u = new URLString( "file://" + deviceName + "/" + this.m_directory.ToString() ); 
                            u.DoDeferredParse();// Presumably the caller of SpecialNormalizeUrl wants a fully parsed URL
                            return u; 
                        } 
                    }
                    else 
                        return this;
                }
                else
                { 
                    return this;
                } 
            } 
        }

        public static bool CompareUrls( URLString url1, URLString url2 )
        { 
            if (url1 == null && url2 == null) 
                return true;
 
            if (url1 == null || url2 == null)
                return false;

            url1.DoDeferredParse(); 
            url2.DoDeferredParse();
 
            URLString normalUrl1 = url1.SpecialNormalizeUrl(); 
            URLString normalUrl2 = url2.SpecialNormalizeUrl();
 
            // Compare protocol (case insensitive)

            if (String.Compare( normalUrl1.m_protocol, normalUrl2.m_protocol, StringComparison.OrdinalIgnoreCase) != 0)
                return false; 

            // Do special processing for file urls 
 
            if (String.Compare( normalUrl1.m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0)
            { 
#if !PLATFORM_UNIX
                if (!normalUrl1.m_localSite.IsSubsetOf( normalUrl2.m_localSite ) ||
                    !normalUrl2.m_localSite.IsSubsetOf( normalUrl1.m_localSite ))
                     return false; 
#else
                return url1.IsSubsetOf( url2 ) && 
                       url2.IsSubsetOf( url1 ); 
#endif // !PLATFORM_UNIX
            } 
            else
            {
                if (String.Compare( normalUrl1.m_userpass, normalUrl2.m_userpass, StringComparison.Ordinal) != 0)
                    return false; 

                if (!normalUrl1.m_siteString.IsSubsetOf( normalUrl2.m_siteString ) || 
                    !normalUrl2.m_siteString.IsSubsetOf( normalUrl1.m_siteString )) 
                    return false;
 
                if (url1.m_port != url2.m_port)
                    return false;
            }
 
            if (!normalUrl1.m_directory.IsSubsetOf( normalUrl2.m_directory ) ||
                !normalUrl2.m_directory.IsSubsetOf( normalUrl1.m_directory )) 
                return false; 

            return true; 
        }

 public bool Equals( URLString url ) 
 {
     return CompareUrls( this, url ); 
 }

        private void ParseURL()
        {
            lock (this)
            {
                if (m_element == null)
                    return;

                String elurl = m_element.Attribute( "Url" );
                if (elurl == null)
                {
                    throw new ArgumentException(Environment.GetResourceString("Argument_UrlCannotBeNull"));
                }
                else
                {
                    URLString url = new URLString(elurl);
                    if (url.IsRelativeFileUrl)
                        throw new ArgumentException(Environment.GetResourceString("Argument_RelativeUrlMembershipCondition"));

                    m_url = url;
                }

                m_element = null;
            }
        }

 private ApplicationDirectory(URLString appDirectory)
 {
     this.m_appDirectory = appDirectory;
 }

 internal UrlIdentityPermission( URLString site )
 {
     m_unrestricted = false;
     m_urls = new URLString[1];
     m_urls[0] = site;
 }

        private static void DemandPermission(string codeBase, bool havePath, int demandFlag)
        {
            FileIOPermissionAccess pathDiscovery = FileIOPermissionAccess.PathDiscovery;
            switch (demandFlag)
            {
                case 1:
                    pathDiscovery = FileIOPermissionAccess.Read;
                    break;

                case 2:
                    pathDiscovery = FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read;
                    break;

                case 3:
                    CreateWebPermission(AssemblyName.EscapeCodeBase(codeBase)).Demand();
                    return;
            }
            if (!havePath)
            {
                codeBase = new URLString(codeBase, true).GetFileName();
            }
            codeBase = Path.GetFullPathInternal(codeBase);
            new FileIOPermission(pathDiscovery, codeBase).Demand();
        }

 private void VerifyCodeBaseDiscovery(string codeBase)
 {
     if ((codeBase != null) && (string.Compare(codeBase, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0))
     {
         URLString str = new URLString(codeBase, true);
         new FileIOPermission(FileIOPermissionAccess.PathDiscovery, str.GetFileName()).Demand();
     }
 }

 internal static RuntimeAssembly InternalLoadAssemblyName(AssemblyName assemblyRef, System.Security.Policy.Evidence assemblySecurity, ref StackCrawlMark stackMark, bool forIntrospection, bool suppressSecurityChecks)
 {
     if (assemblyRef == null)
     {
         throw new ArgumentNullException("assemblyRef");
     }
     assemblyRef = (AssemblyName) assemblyRef.Clone();
     if (assemblySecurity != null)
     {
         if (!AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
         {
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
         }
         if (!suppressSecurityChecks)
         {
             new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
         }
     }
     string strA = VerifyCodeBase(assemblyRef.CodeBase);
     if ((strA != null) && !suppressSecurityChecks)
     {
         if (string.Compare(strA, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) != 0)
         {
             CreateWebPermission(assemblyRef.EscapedCodeBase).Demand();
         }
         else
         {
             URLString str2 = new URLString(strA, true);
             new FileIOPermission(FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, str2.GetFileName()).Demand();
         }
     }
     return nLoad(assemblyRef, strA, assemblySecurity, null, ref stackMark, true, forIntrospection, suppressSecurityChecks);
 }