text:
from __future__ import absolute_import, division, print_function

import abc
import datetime
import hashlib
import ipaddress
import warnings
from enum import Enum

from asn1crypto.keys import PublicKeyInfo

import six

from cryptography import utils
from cryptography.hazmat.primitives import constant_time, serialization
from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePublicKey
from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
from cryptography.x509.certificate_transparency import (
    SignedCertificateTimestamp
)
from cryptography.x509.general_name import GeneralName, IPAddress, OtherName
from cryptography.x509.name import RelativeDistinguishedName
from cryptography.x509.oid import (
    CRLEntryExtensionOID, ExtensionOID, OCSPExtensionOID, ObjectIdentifier,
)

def _key_identifier_from_public_key(public_key):
    if isinstance(public_key, RSAPublicKey):
        data = public_key.public_bytes(
            serialization.Encoding.DER,
            serialization.PublicFormat.PKCS1,
        )
    elif isinstance(public_key, EllipticCurvePublicKey):
        data = public_key.public_bytes(
            serialization.Encoding.X962,
            serialization.PublicFormat.UncompressedPoint
        )
    else:
        # This is a very slow way to do this.
        serialized = public_key.public_bytes(
            serialization.Encoding.DER,
            serialization.PublicFormat.SubjectPublicKeyInfo
        )

        data = bytes(PublicKeyInfo.load(serialized)['public_key'])

    return hashlib.sha1(data).digest()

class DuplicateExtension(Exception):
    def __init__(self, msg, oid):
        super(DuplicateExtension, self).__init__(msg)
        self.oid = oid

class ExtensionNotFound(Exception):
    def __init__(self, msg, oid):
        super(ExtensionNotFound, self).__init__(msg)
        self.oid = oid

@six.add_metaclass(abc.ABCMeta)
class ExtensionType(object):
    @abc.abstractproperty
    def oid(self):
        """
        Returns the oid associated with the given extension type.
        """

class Extensions(object):
    def __init__(self, extensions):
        self._extensions = extensions

    def get_extension_for_oid(self, oid):
        for ext in self:
            if ext.oid == oid:
                return ext

        raise ExtensionNotFound("No {} extension was found".format(oid), oid)

    def get_extension_for_class(self, extclass):
        if extclass is UnrecognizedExtension:
            raise TypeError(
                "UnrecognizedExtension can't be used with "
                "get_extension_for_class because more than one instance of the"
                " class may be present."
            )

        for ext in self:
            if isinstance(ext.value, extclass):
                return ext

        raise ExtensionNotFound(
            "No {} extension was found".format(extclass), extclass.oid
        )

    def __iter__(self):
        return iter(self._extensions)

    def __len__(self):
        return len(self._extensions)

    def __getitem__(self, idx):
        return self._extensions[idx]

    def __repr__(self):
        return (
            "<Extensions({})>".format(self._extensions)
        )

@utils.register_interface(ExtensionType)
class CRLNumber(object):
    oid = ExtensionOID.CRL_NUMBER

    def __init__(self, crl_number):
        if not isinstance(crl_number, six.integer_types):
            raise TypeError("crl_number must be an integer")

        self._crl_number = crl_number

    def __eq__(self, other):
        if not isinstance(other, CRLNumber):
            return NotImplemented

        return self.crl_number == other.crl_number

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.crl_number)

    def __repr__(self):
        return "<CRLNumber({})>".format(self.crl_number)

    crl_number = utils.read_only_property("_crl_number")

@utils.register_interface(ExtensionType)
class AuthorityKeyIdentifier(object):
    oid = ExtensionOID.AUTHORITY_KEY_IDENTIFIER

    def __init__(self, key_identifier, authority_cert_issuer,
                 authority_cert_serial_number):
        if (authority_cert_issuer is None) != (
            authority_cert_serial_number is None
        ):
            raise ValueError(
                "authority_cert_issuer and authority_cert_serial_number "
                "must both be present or both None"
            )

        if authority_cert_issuer is not None:
            authority_cert_issuer = list(authority_cert_issuer)
            if not all(
                isinstance(x, GeneralName) for x in authority_cert_issuer
            ):
                raise TypeError(
                    "authority_cert_issuer must be a list of GeneralName "
                    "objects"
                )

        if authority_cert_serial_number is not None and not isinstance(
            authority_cert_serial_number, six.integer_types
        ):
            raise TypeError(
                "authority_cert_serial_number must be an integer"
            )

        self._key_identifier = key_identifier
        self._authority_cert_issuer = authority_cert_issuer
        self._authority_cert_serial_number = authority_cert_serial_number

    @classmethod
    def from_issuer_public_key(cls, public_key):
        digest = _key_identifier_from_public_key(public_key)
        return cls(
            key_identifier=digest,
            authority_cert_issuer=None,
            authority_cert_serial_number=None
        )

    @classmethod
    def from_issuer_subject_key_identifier(cls, ski):
        if isinstance(ski, SubjectKeyIdentifier):
            digest = ski.digest
        else:
            digest = ski.value.digest
            warnings.warn(
                "Extension objects are deprecated as arguments to "
                "from_issuer_subject_key_identifier and support will be "
                "removed soon. Please migrate to passing a "
                "SubjectKeyIdentifier directly.",
                utils.DeprecatedIn27,
                stacklevel=2,
            )

        return cls(
            key_identifier=digest,
            authority_cert_issuer=None,
            authority_cert_serial_number=None
        )

    def __repr__(self):
        return (
            "<AuthorityKeyIdentifier(key_identifier={0.key_identifier!r}, "
            "authority_cert_issuer={0.authority_cert_issuer}, "
            "authority_cert_serial_number={0.authority_cert_serial_number}"
            ")>".format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, AuthorityKeyIdentifier):
            return NotImplemented

        return (
            self.key_identifier == other.key_identifier and
            self.authority_cert_issuer == other.authority_cert_issuer and
            self.authority_cert_serial_number ==
            other.authority_cert_serial_number
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        if self.authority_cert_issuer is None:
            aci = None
        else:
            aci = tuple(self.authority_cert_issuer)
        return hash((
            self.key_identifier, aci, self.authority_cert_serial_number
        ))

    key_identifier = utils.read_only_property("_key_identifier")
    authority_cert_issuer = utils.read_only_property("_authority_cert_issuer")
    authority_cert_serial_number = utils.read_only_property(
        "_authority_cert_serial_number"
    )

@utils.register_interface(ExtensionType)
class SubjectKeyIdentifier(object):
    oid = ExtensionOID.SUBJECT_KEY_IDENTIFIER

    def __init__(self, digest):
        self._digest = digest

    @classmethod
    def from_public_key(cls, public_key):
        return cls(_key_identifier_from_public_key(public_key))

    digest = utils.read_only_property("_digest")

    def __repr__(self):
        return "<SubjectKeyIdentifier(digest={0!r})>".format(self.digest)

    def __eq__(self, other):
        if not isinstance(other, SubjectKeyIdentifier):
            return NotImplemented

        return constant_time.bytes_eq(self.digest, other.digest)

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.digest)

@utils.register_interface(ExtensionType)
class AuthorityInformationAccess(object):
    oid = ExtensionOID.AUTHORITY_INFORMATION_ACCESS

    def __init__(self, descriptions):
        descriptions = list(descriptions)
        if not all(isinstance(x, AccessDescription) for x in descriptions):
            raise TypeError(
                "Every item in the descriptions list must be an "
                "AccessDescription"
            )

        self._descriptions = descriptions

    def __iter__(self):
        return iter(self._descriptions)

    def __len__(self):
        return len(self._descriptions)

    def __repr__(self):
        return "<AuthorityInformationAccess({})>".format(self._descriptions)

    def __eq__(self, other):
        if not isinstance(other, AuthorityInformationAccess):
            return NotImplemented

        return self._descriptions == other._descriptions

    def __ne__(self, other):
        return not self == other

    def __getitem__(self, idx):
        return self._descriptions[idx]

    def __hash__(self):
        return hash(tuple(self._descriptions))

class AccessDescription(object):
    def __init__(self, access_method, access_location):
        if not isinstance(access_method, ObjectIdentifier):
            raise TypeError("access_method must be an ObjectIdentifier")

        if not isinstance(access_location, GeneralName):
            raise TypeError("access_location must be a GeneralName")

        self._access_method = access_method
        self._access_location = access_location

    def __repr__(self):
        return (
            "<AccessDescription(access_method={0.access_method}, access_locati"
            "on={0.access_location})>".format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, AccessDescription):
            return NotImplemented

        return (
            self.access_method == other.access_method and
            self.access_location == other.access_location
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.access_method, self.access_location))

    access_method = utils.read_only_property("_access_method")
    access_location = utils.read_only_property("_access_location")

@utils.register_interface(ExtensionType)
class BasicConstraints(object):
    oid = ExtensionOID.BASIC_CONSTRAINTS

    def __init__(self, ca, path_length):
        if not isinstance(ca, bool):
            raise TypeError("ca must be a boolean value")

        if path_length is not None and not ca:
            raise ValueError("path_length must be None when ca is False")

        if (
            path_length is not None and
            (not isinstance(path_length, six.integer_types) or path_length < 0)
        ):
            raise TypeError(
                "path_length must be a non-negative integer or None"
            )

        self._ca = ca
        self._path_length = path_length

    ca = utils.read_only_property("_ca")
    path_length = utils.read_only_property("_path_length")

    def __repr__(self):
        return ("<BasicConstraints(ca={0.ca}, "
                "path_length={0.path_length})>").format(self)

    def __eq__(self, other):
        if not isinstance(other, BasicConstraints):
            return NotImplemented

        return self.ca == other.ca and self.path_length == other.path_length

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.ca, self.path_length))

@utils.register_interface(ExtensionType)
class DeltaCRLIndicator(object):
    oid = ExtensionOID.DELTA_CRL_INDICATOR

    def __init__(self, crl_number):
        if not isinstance(crl_number, six.integer_types):
            raise TypeError("crl_number must be an integer")

        self._crl_number = crl_number

    crl_number = utils.read_only_property("_crl_number")

    def __eq__(self, other):
        if not isinstance(other, DeltaCRLIndicator):
            return NotImplemented

        return self.crl_number == other.crl_number

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.crl_number)

    def __repr__(self):
        return "<DeltaCRLIndicator(crl_number={0.crl_number})>".format(self)

@utils.register_interface(ExtensionType)
class CRLDistributionPoints(object):
    oid = ExtensionOID.CRL_DISTRIBUTION_POINTS

    def __init__(self, distribution_points):
        distribution_points = list(distribution_points)
        if not all(
            isinstance(x, DistributionPoint) for x in distribution_points
        ):
            raise TypeError(
                "distribution_points must be a list of DistributionPoint "
                "objects"
            )

        self._distribution_points = distribution_points

    def __iter__(self):
        return iter(self._distribution_points)

    def __len__(self):
        return len(self._distribution_points)

    def __repr__(self):
        return "<CRLDistributionPoints({})>".format(self._distribution_points)

    def __eq__(self, other):
        if not isinstance(other, CRLDistributionPoints):
            return NotImplemented

        return self._distribution_points == other._distribution_points

    def __ne__(self, other):
        return not self == other

    def __getitem__(self, idx):
        return self._distribution_points[idx]

    def __hash__(self):
        return hash(tuple(self._distribution_points))

@utils.register_interface(ExtensionType)
class FreshestCRL(object):
    oid = ExtensionOID.FRESHEST_CRL

    def __init__(self, distribution_points):
        distribution_points = list(distribution_points)
        if not all(
            isinstance(x, DistributionPoint) for x in distribution_points
        ):
            raise TypeError(
                "distribution_points must be a list of DistributionPoint "
                "objects"
            )

        self._distribution_points = distribution_points

    def __iter__(self):
        return iter(self._distribution_points)

    def __len__(self):
        return len(self._distribution_points)

    def __repr__(self):
        return "<FreshestCRL({})>".format(self._distribution_points)

    def __eq__(self, other):
        if not isinstance(other, FreshestCRL):
            return NotImplemented

        return self._distribution_points == other._distribution_points

    def __ne__(self, other):
        return not self == other

    def __getitem__(self, idx):
        return self._distribution_points[idx]

    def __hash__(self):
        return hash(tuple(self._distribution_points))

class DistributionPoint(object):
    def __init__(self, full_name, relative_name, reasons, crl_issuer):
        if full_name and relative_name:
            raise ValueError(
                "You cannot provide both full_name and relative_name, at "
                "least one must be None."
            )

        if full_name:
            full_name = list(full_name)
            if not all(isinstance(x, GeneralName) for x in full_name):
                raise TypeError(
                    "full_name must be a list of GeneralName objects"
                )

        if relative_name:
            if not isinstance(relative_name, RelativeDistinguishedName):
                raise TypeError(
                    "relative_name must be a RelativeDistinguishedName"
                )

        if crl_issuer:
            crl_issuer = list(crl_issuer)
            if not all(isinstance(x, GeneralName) for x in crl_issuer):
                raise TypeError(
                    "crl_issuer must be None or a list of general names"
                )

        if reasons and (not isinstance(reasons, frozenset) or not all(
            isinstance(x, ReasonFlags) for x in reasons
        )):
            raise TypeError("reasons must be None or frozenset of ReasonFlags")

        if reasons and (
            ReasonFlags.unspecified in reasons or
            ReasonFlags.remove_from_crl in reasons
        ):
            raise ValueError(
                "unspecified and remove_from_crl are not valid reasons in a "
                "DistributionPoint"
            )

        if reasons and not crl_issuer and not (full_name or relative_name):
            raise ValueError(
                "You must supply crl_issuer, full_name, or relative_name when "
                "reasons is not None"
            )

        self._full_name = full_name
        self._relative_name = relative_name
        self._reasons = reasons
        self._crl_issuer = crl_issuer

    def __repr__(self):
        return (
            "<DistributionPoint(full_name={0.full_name}, relative_name={0.rela"
            "tive_name}, reasons={0.reasons}, crl_issuer={0.crl_issuer})>"
            .format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, DistributionPoint):
            return NotImplemented

        return (
            self.full_name == other.full_name and
            self.relative_name == other.relative_name and
            self.reasons == other.reasons and
            self.crl_issuer == other.crl_issuer
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        if self.full_name is not None:
            fn = tuple(self.full_name)
        else:
            fn = None

        if self.crl_issuer is not None:
            crl_issuer = tuple(self.crl_issuer)
        else:
            crl_issuer = None

        return hash((fn, self.relative_name, self.reasons, crl_issuer))

    full_name = utils.read_only_property("_full_name")
    relative_name = utils.read_only_property("_relative_name")
    reasons = utils.read_only_property("_reasons")
    crl_issuer = utils.read_only_property("_crl_issuer")

class ReasonFlags(Enum):
    unspecified = "unspecified"
    key_compromise = "keyCompromise"
    ca_compromise = "cACompromise"
    affiliation_changed = "affiliationChanged"
    superseded = "superseded"
    cessation_of_operation = "cessationOfOperation"
    certificate_hold = "certificateHold"
    privilege_withdrawn = "privilegeWithdrawn"
    aa_compromise = "aACompromise"
    remove_from_crl = "removeFromCRL"

@utils.register_interface(ExtensionType)
class PolicyConstraints(object):
    oid = ExtensionOID.POLICY_CONSTRAINTS

    def __init__(self, require_explicit_policy, inhibit_policy_mapping):
        if require_explicit_policy is not None and not isinstance(
            require_explicit_policy, six.integer_types
        ):
            raise TypeError(
                "require_explicit_policy must be a non-negative integer or "
                "None"
            )

        if inhibit_policy_mapping is not None and not isinstance(
            inhibit_policy_mapping, six.integer_types
        ):
            raise TypeError(
                "inhibit_policy_mapping must be a non-negative integer or None"
            )

        if inhibit_policy_mapping is None and require_explicit_policy is None:
            raise ValueError(
                "At least one of require_explicit_policy and "
                "inhibit_policy_mapping must not be None"
            )

        self._require_explicit_policy = require_explicit_policy
        self._inhibit_policy_mapping = inhibit_policy_mapping

    def __repr__(self):
        return (
            u"<PolicyConstraints(require_explicit_policy={0.require_explicit"
            u"_policy}, inhibit_policy_mapping={0.inhibit_policy_"
            u"mapping})>".format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, PolicyConstraints):
            return NotImplemented

        return (
            self.require_explicit_policy == other.require_explicit_policy and
            self.inhibit_policy_mapping == other.inhibit_policy_mapping
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(
            (self.require_explicit_policy, self.inhibit_policy_mapping)
        )

    require_explicit_policy = utils.read_only_property(
        "_require_explicit_policy"
    )
    inhibit_policy_mapping = utils.read_only_property(
        "_inhibit_policy_mapping"
    )

@utils.register_interface(ExtensionType)
class CertificatePolicies(object):
    oid = ExtensionOID.CERTIFICATE_POLICIES

    def __init__(self, policies):
        policies = list(policies)
        if not all(isinstance(x, PolicyInformation) for x in policies):
            raise TypeError(
                "Every item in the policies list must be a "
                "PolicyInformation"
            )

        self._policies = policies

    def __iter__(self):
        return iter(self._policies)

    def __len__(self):
        return len(self._policies)

    def __repr__(self):
        return "<CertificatePolicies({})>".format(self._policies)

    def __eq__(self, other):
        if not isinstance(other, CertificatePolicies):
            return NotImplemented

        return self._policies == other._policies

    def __ne__(self, other):
        return not self == other

    def __getitem__(self, idx):
        return self._policies[idx]

    def __hash__(self):
        return hash(tuple(self._policies))

class PolicyInformation(object):
    def __init__(self, policy_identifier, policy_qualifiers):
        if not isinstance(policy_identifier, ObjectIdentifier):
            raise TypeError("policy_identifier must be an ObjectIdentifier")

        self._policy_identifier = policy_identifier

        if policy_qualifiers:
            policy_qualifiers = list(policy_qualifiers)
            if not all(
                    isinstance(x, (six.text_type, UserNotice))
                    for x in policy_qualifiers
            ):
                raise TypeError(
                    "policy_qualifiers must be a list of strings and/or "
                    "UserNotice objects or None"
                )

        self._policy_qualifiers = policy_qualifiers

    def __repr__(self):
        return (
            "<PolicyInformation(policy_identifier={0.policy_identifier}, polic"
            "y_qualifiers={0.policy_qualifiers})>".format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, PolicyInformation):
            return NotImplemented

        return (
            self.policy_identifier == other.policy_identifier and
            self.policy_qualifiers == other.policy_qualifiers
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        if self.policy_qualifiers is not None:
            pq = tuple(self.policy_qualifiers)
        else:
            pq = None

        return hash((self.policy_identifier, pq))

    policy_identifier = utils.read_only_property("_policy_identifier")
    policy_qualifiers = utils.read_only_property("_policy_qualifiers")

class UserNotice(object):
    def __init__(self, notice_reference, explicit_text):
        if notice_reference and not isinstance(
            notice_reference, NoticeReference
        ):
            raise TypeError(
                "notice_reference must be None or a NoticeReference"
            )

        self._notice_reference = notice_reference
        self._explicit_text = explicit_text

    def __repr__(self):
        return (
            "<UserNotice(notice_reference={0.notice_reference}, explicit_text="
            "{0.explicit_text!r})>".format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, UserNotice):
            return NotImplemented

        return (
            self.notice_reference == other.notice_reference and
            self.explicit_text == other.explicit_text
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.notice_reference, self.explicit_text))

    notice_reference = utils.read_only_property("_notice_reference")
    explicit_text = utils.read_only_property("_explicit_text")

class NoticeReference(object):
    def __init__(self, organization, notice_numbers):
        self._organization = organization
        notice_numbers = list(notice_numbers)
        if not all(isinstance(x, int) for x in notice_numbers):
            raise TypeError(
                "notice_numbers must be a list of integers"
            )

        self._notice_numbers = notice_numbers

    def __repr__(self):
        return (
            "<NoticeReference(organization={0.organization!r}, notice_numbers="
            "{0.notice_numbers})>".format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, NoticeReference):
            return NotImplemented

        return (
            self.organization == other.organization and
            self.notice_numbers == other.notice_numbers
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.organization, tuple(self.notice_numbers)))

    organization = utils.read_only_property("_organization")
    notice_numbers = utils.read_only_property("_notice_numbers")

@utils.register_interface(ExtensionType)
class ExtendedKeyUsage(object):
    oid = ExtensionOID.EXTENDED_KEY_USAGE

    def __init__(self, usages):
        usages = list(usages)
        if not all(isinstance(x, ObjectIdentifier) for x in usages):
            raise TypeError(
                "Every item in the usages list must be an ObjectIdentifier"
            )

        self._usages = usages

    def __iter__(self):
        return iter(self._usages)

    def __len__(self):
        return len(self._usages)

    def __repr__(self):
        return "<ExtendedKeyUsage({})>".format(self._usages)

    def __eq__(self, other):
        if not isinstance(other, ExtendedKeyUsage):
            return NotImplemented

        return self._usages == other._usages

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._usages))

@utils.register_interface(ExtensionType)
class OCSPNoCheck(object):
    oid = ExtensionOID.OCSP_NO_CHECK

    def __eq__(self, other):
        if not isinstance(other, OCSPNoCheck):
            return NotImplemented

        return True

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(OCSPNoCheck)

    def __repr__(self):
        return "<OCSPNoCheck()>"

@utils.register_interface(ExtensionType)
class PrecertPoison(object):
    oid = ExtensionOID.PRECERT_POISON

    def __eq__(self, other):
        if not isinstance(other, PrecertPoison):
            return NotImplemented

        return True

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(PrecertPoison)

    def __repr__(self):
        return "<PrecertPoison()>"

@utils.register_interface(ExtensionType)
class TLSFeature(object):
    oid = ExtensionOID.TLS_FEATURE

    def __init__(self, features):
        features = list(features)
        if (
            not all(isinstance(x, TLSFeatureType) for x in features) or
            len(features) == 0
        ):
            raise TypeError(
                "features must be a list of elements from the TLSFeatureType "
                "enum"
            )

        self._features = features

    def __iter__(self):
        return iter(self._features)

    def __len__(self):
        return len(self._features)

    def __repr__(self):
        return "<TLSFeature(features={0._features})>".format(self)

    def __eq__(self, other):
        if not isinstance(other, TLSFeature):
            return NotImplemented

        return self._features == other._features

    def __getitem__(self, idx):
        return self._features[idx]

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._features))

class TLSFeatureType(Enum):
    # status_request is defined in RFC 6066 and is used for what is commonly
    # called OCSP Must-Staple when present in the TLS Feature extension in an
    # X.509 certificate.
    status_request = 5
    # status_request_v2 is defined in RFC 6961 and allows multiple OCSP
    # responses to be provided. It is not currently in use by clients or
    # servers.
    status_request_v2 = 17

_TLS_FEATURE_TYPE_TO_ENUM = dict((x.value, x) for x in TLSFeatureType)

@utils.register_interface(ExtensionType)
class InhibitAnyPolicy(object):
    oid = ExtensionOID.INHIBIT_ANY_POLICY

    def __init__(self, skip_certs):
        if not isinstance(skip_certs, six.integer_types):
            raise TypeError("skip_certs must be an integer")

        if skip_certs < 0:
            raise ValueError("skip_certs must be a non-negative integer")

        self._skip_certs = skip_certs

    def __repr__(self):
        return "<InhibitAnyPolicy(skip_certs={0.skip_certs})>".format(self)

    def __eq__(self, other):
        if not isinstance(other, InhibitAnyPolicy):
            return NotImplemented

        return self.skip_certs == other.skip_certs

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.skip_certs)

    skip_certs = utils.read_only_property("_skip_certs")

@utils.register_interface(ExtensionType)
class KeyUsage(object):
    oid = ExtensionOID.KEY_USAGE

    def __init__(self, digital_signature, content_commitment, key_encipherment,
                 data_encipherment, key_agreement, key_cert_sign, crl_sign,
                 encipher_only, decipher_only):
        if not key_agreement and (encipher_only or decipher_only):
            raise ValueError(
                "encipher_only and decipher_only can only be true when "
                "key_agreement is true"
            )

        self._digital_signature = digital_signature
        self._content_commitment = content_commitment
        self._key_encipherment = key_encipherment
        self._data_encipherment = data_encipherment
        self._key_agreement = key_agreement
        self._key_cert_sign = key_cert_sign
        self._crl_sign = crl_sign
        self._encipher_only = encipher_only
        self._decipher_only = decipher_only

    digital_signature = utils.read_only_property("_digital_signature")
    content_commitment = utils.read_only_property("_content_commitment")
    key_encipherment = utils.read_only_property("_key_encipherment")
    data_encipherment = utils.read_only_property("_data_encipherment")
    key_agreement = utils.read_only_property("_key_agreement")
    key_cert_sign = utils.read_only_property("_key_cert_sign")
    crl_sign = utils.read_only_property("_crl_sign")

    @property
    def encipher_only(self):
        if not self.key_agreement:
            raise ValueError(
                "encipher_only is undefined unless key_agreement is true"
            )
        else:
            return self._encipher_only

    @property
    def decipher_only(self):
        if not self.key_agreement:
            raise ValueError(
                "decipher_only is undefined unless key_agreement is true"
            )
        else:
            return self._decipher_only

    def __repr__(self):
        try:
            encipher_only = self.encipher_only
            decipher_only = self.decipher_only
        except ValueError:
            encipher_only = None
            decipher_only = None

        return ("<KeyUsage(digital_signature={0.digital_signature}, "
                "content_commitment={0.content_commitment}, "
                "key_encipherment={0.key_encipherment}, "
                "data_encipherment={0.data_encipherment}, "
                "key_agreement={0.key_agreement}, "
                "key_cert_sign={0.key_cert_sign}, crl_sign={0.crl_sign}, "
                "encipher_only={1}, decipher_only={2})>").format(
                    self, encipher_only, decipher_only)

    def __eq__(self, other):
        if not isinstance(other, KeyUsage):
            return NotImplemented

        return (
            self.digital_signature == other.digital_signature and
            self.content_commitment == other.content_commitment and
            self.key_encipherment == other.key_encipherment and
            self.data_encipherment == other.data_encipherment and
            self.key_agreement == other.key_agreement and
            self.key_cert_sign == other.key_cert_sign and
            self.crl_sign == other.crl_sign and
            self._encipher_only == other._encipher_only and
            self._decipher_only == other._decipher_only
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((
            self.digital_signature, self.content_commitment,
            self.key_encipherment, self.data_encipherment,
            self.key_agreement, self.key_cert_sign,
            self.crl_sign, self._encipher_only,
            self._decipher_only
        ))

@utils.register_interface(ExtensionType)
class NameConstraints(object):
    oid = ExtensionOID.NAME_CONSTRAINTS

    def __init__(self, permitted_subtrees, excluded_subtrees):
        if permitted_subtrees is not None:
            permitted_subtrees = list(permitted_subtrees)
            if not all(
                isinstance(x, GeneralName) for x in permitted_subtrees
            ):
                raise TypeError(
                    "permitted_subtrees must be a list of GeneralName objects "
                    "or None"
                )

            self._validate_ip_name(permitted_subtrees)

        if excluded_subtrees is not None:
            excluded_subtrees = list(excluded_subtrees)
            if not all(
                isinstance(x, GeneralName) for x in excluded_subtrees
            ):
                raise TypeError(
                    "excluded_subtrees must be a list of GeneralName objects "
                    "or None"
                )

            self._validate_ip_name(excluded_subtrees)

        if permitted_subtrees is None and excluded_subtrees is None:
            raise ValueError(
                "At least one of permitted_subtrees and excluded_subtrees "
                "must not be None"
            )

        self._permitted_subtrees = permitted_subtrees
        self._excluded_subtrees = excluded_subtrees

    def __eq__(self, other):
        if not isinstance(other, NameConstraints):
            return NotImplemented

        return (
            self.excluded_subtrees == other.excluded_subtrees and
            self.permitted_subtrees == other.permitted_subtrees
        )

    def __ne__(self, other):
        return not self == other

    def _validate_ip_name(self, tree):
        if any(isinstance(name, IPAddress) and not isinstance(
            name.value, (ipaddress.IPv4Network, ipaddress.IPv6Network)
        ) for name in tree):
            raise TypeError(
                "IPAddress name constraints must be an IPv4Network or"
                " IPv6Network object"
            )

    def __repr__(self):
        return (
            u"<NameConstraints(permitted_subtrees={0.permitted_subtrees}, "
            u"excluded_subtrees={0.excluded_subtrees})>".format(self)
        )

    def __hash__(self):
        if self.permitted_subtrees is not None:
            ps = tuple(self.permitted_subtrees)
        else:
            ps = None

        if self.excluded_subtrees is not None:
            es = tuple(self.excluded_subtrees)
        else:
            es = None

        return hash((ps, es))

    permitted_subtrees = utils.read_only_property("_permitted_subtrees")
    excluded_subtrees = utils.read_only_property("_excluded_subtrees")

class Extension(object):
    def __init__(self, oid, critical, value):
        if not isinstance(oid, ObjectIdentifier):
            raise TypeError(
                "oid argument must be an ObjectIdentifier instance."
            )

        if not isinstance(critical, bool):
            raise TypeError("critical must be a boolean value")

        self._oid = oid
        self._critical = critical
        self._value = value

    oid = utils.read_only_property("_oid")
    critical = utils.read_only_property("_critical")
    value = utils.read_only_property("_value")

    def __repr__(self):
        return ("<Extension(oid={0.oid}, critical={0.critical}, "
                "value={0.value})>").format(self)

    def __eq__(self, other):
        if not isinstance(other, Extension):
            return NotImplemented

        return (
            self.oid == other.oid and
            self.critical == other.critical and
            self.value == other.value
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.oid, self.critical, self.value))

class GeneralNames(object):
    def __init__(self, general_names):
        general_names = list(general_names)
        if not all(isinstance(x, GeneralName) for x in general_names):
            raise TypeError(
                "Every item in the general_names list must be an "
                "object conforming to the GeneralName interface"
            )

        self._general_names = general_names

    def __iter__(self):
        return iter(self._general_names)

    def __len__(self):
        return len(self._general_names)

    def get_values_for_type(self, type):
        # Return the value of each GeneralName, except for OtherName instances
        # which we return directly because it has two important properties not
        # just one value.
        objs = (i for i in self if isinstance(i, type))
        if type != OtherName:
            objs = (i.value for i in objs)
        return list(objs)

    def __repr__(self):
        return "<GeneralNames({})>".format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, GeneralNames):
            return NotImplemented

        return self._general_names == other._general_names

    def __ne__(self, other):
        return not self == other

    def __getitem__(self, idx):
        return self._general_names[idx]

    def __hash__(self):
        return hash(tuple(self._general_names))

@utils.register_interface(ExtensionType)
class SubjectAlternativeName(object):
    oid = ExtensionOID.SUBJECT_ALTERNATIVE_NAME

    def __init__(self, general_names):
        self._general_names = GeneralNames(general_names)

    def __iter__(self):
        return iter(self._general_names)

    def __len__(self):
        return len(self._general_names)

    def get_values_for_type(self, type):
        return self._general_names.get_values_for_type(type)

    def __repr__(self):
        return "<SubjectAlternativeName({})>".format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, SubjectAlternativeName):
            return NotImplemented

        return self._general_names == other._general_names

    def __getitem__(self, idx):
        return self._general_names[idx]

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self._general_names)

@utils.register_interface(ExtensionType)
class IssuerAlternativeName(object):
    oid = ExtensionOID.ISSUER_ALTERNATIVE_NAME

    def __init__(self, general_names):
        self._general_names = GeneralNames(general_names)

    def __iter__(self):
        return iter(self._general_names)

    def __len__(self):
        return len(self._general_names)

    def get_values_for_type(self, type):
        return self._general_names.get_values_for_type(type)

    def __repr__(self):
        return "<IssuerAlternativeName({})>".format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, IssuerAlternativeName):
            return NotImplemented

        return self._general_names == other._general_names

    def __ne__(self, other):
        return not self == other

    def __getitem__(self, idx):
        return self._general_names[idx]

    def __hash__(self):
        return hash(self._general_names)

@utils.register_interface(ExtensionType)
class CertificateIssuer(object):
    oid = CRLEntryExtensionOID.CERTIFICATE_ISSUER

    def __init__(self, general_names):
        self._general_names = GeneralNames(general_names)

    def __iter__(self):
        return iter(self._general_names)

    def __len__(self):
        return len(self._general_names)

    def get_values_for_type(self, type):
        return self._general_names.get_values_for_type(type)

    def __repr__(self):
        return "<CertificateIssuer({})>".format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, CertificateIssuer):
            return NotImplemented

        return self._general_names == other._general_names

    def __ne__(self, other):
        return not self == other

    def __getitem__(self, idx):
        return self._general_names[idx]

    def __hash__(self):
        return hash(self._general_names)

@utils.register_interface(ExtensionType)
class CRLReason(object):
    oid = CRLEntryExtensionOID.CRL_REASON

    def __init__(self, reason):
        if not isinstance(reason, ReasonFlags):
            raise TypeError("reason must be an element from ReasonFlags")

        self._reason = reason

    def __repr__(self):
        return "<CRLReason(reason={})>".format(self._reason)

    def __eq__(self, other):
        if not isinstance(other, CRLReason):
            return NotImplemented

        return self.reason == other.reason

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.reason)

    reason = utils.read_only_property("_reason")

@utils.register_interface(ExtensionType)
class InvalidityDate(object):
    oid = CRLEntryExtensionOID.INVALIDITY_DATE

    def __init__(self, invalidity_date):
        if not isinstance(invalidity_date, datetime.datetime):
            raise TypeError("invalidity_date must be a datetime.datetime")

        self._invalidity_date = invalidity_date

    def __repr__(self):
        return "<InvalidityDate(invalidity_date={})>".format(
            self._invalidity_date
        )

    def __eq__(self, other):
        if not isinstance(other, InvalidityDate):
            return NotImplemented

        return self.invalidity_date == other.invalidity_date

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.invalidity_date)

    invalidity_date = utils.read_only_property("_invalidity_date")

@utils.register_interface(ExtensionType)
class PrecertificateSignedCertificateTimestamps(object):
    oid = ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS

    def __init__(self, signed_certificate_timestamps):
        signed_certificate_timestamps = list(signed_certificate_timestamps)
        if not all(
            isinstance(sct, SignedCertificateTimestamp)
            for sct in signed_certificate_timestamps
        ):
            raise TypeError(
                "Every item in the signed_certificate_timestamps list must be "
                "a SignedCertificateTimestamp"
            )
        self._signed_certificate_timestamps = signed_certificate_timestamps

    def __iter__(self):
        return iter(self._signed_certificate_timestamps)

    def __len__(self):
        return len(self._signed_certificate_timestamps)

    def __getitem__(self, idx):
        return self._signed_certificate_timestamps[idx]

    def __repr__(self):
        return (
            "<PrecertificateSignedCertificateTimestamps({})>".format(
                list(self)
            )
        )

    def __hash__(self):
        return hash(tuple(self._signed_certificate_timestamps))

    def __eq__(self, other):
        if not isinstance(other, PrecertificateSignedCertificateTimestamps):
            return NotImplemented

        return (
            self._signed_certificate_timestamps ==
            other._signed_certificate_timestamps
        )

    def __ne__(self, other):
        return not self == other

@utils.register_interface(ExtensionType)
class OCSPNonce(object):
    oid = OCSPExtensionOID.NONCE

    def __init__(self, nonce):
        if not isinstance(nonce, bytes):
            raise TypeError("nonce must be bytes")

        self._nonce = nonce

    def __eq__(self, other):
        if not isinstance(other, OCSPNonce):
            return NotImplemented

        return self.nonce == other.nonce

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.nonce)

    def __repr__(self):
        return "<OCSPNonce(nonce={0.nonce!r})>".format(self)

    nonce = utils.read_only_property("_nonce")

@utils.register_interface(ExtensionType)
class IssuingDistributionPoint(object):
    oid = ExtensionOID.ISSUING_DISTRIBUTION_POINT

    def __init__(self, full_name, relative_name, only_contains_user_certs,
                 only_contains_ca_certs, only_some_reasons, indirect_crl,
                 only_contains_attribute_certs):
        if (
            only_some_reasons and (
                not isinstance(only_some_reasons, frozenset) or not all(
                    isinstance(x, ReasonFlags) for x in only_some_reasons
                )
            )
        ):
            raise TypeError(
                "only_some_reasons must be None or frozenset of ReasonFlags"
            )

        if only_some_reasons and (
            ReasonFlags.unspecified in only_some_reasons or
            ReasonFlags.remove_from_crl in only_some_reasons
        ):
            raise ValueError(
                "unspecified and remove_from_crl are not valid reasons in an "
                "IssuingDistributionPoint"
            )

        if not (
            isinstance(only_contains_user_certs, bool) and
            isinstance(only_contains_ca_certs, bool) and
            isinstance(indirect_crl, bool) and
            isinstance(only_contains_attribute_certs, bool)
        ):
            raise TypeError(
                "only_contains_user_certs, only_contains_ca_certs, "
                "indirect_crl and only_contains_attribute_certs "
                "must all be boolean."
            )

        crl_constraints = [
            only_contains_user_certs, only_contains_ca_certs,
            indirect_crl, only_contains_attribute_certs
        ]

        if len([x for x in crl_constraints if x]) > 1:
            raise ValueError(
                "Only one of the following can be set to True: "
                "only_contains_user_certs, only_contains_ca_certs, "
                "indirect_crl, only_contains_attribute_certs"
            )

        if (
            not any([
                only_contains_user_certs, only_contains_ca_certs,
                indirect_crl, only_contains_attribute_certs, full_name,
                relative_name, only_some_reasons
            ])
        ):
            raise ValueError(
                "Cannot create empty extension: "
                "if only_contains_user_certs, only_contains_ca_certs, "
                "indirect_crl, and only_contains_attribute_certs are all False"
                ", then either full_name, relative_name, or only_some_reasons "
                "must have a value."
            )

        self._only_contains_user_certs = only_contains_user_certs
        self._only_contains_ca_certs = only_contains_ca_certs
        self._indirect_crl = indirect_crl
        self._only_contains_attribute_certs = only_contains_attribute_certs
        self._only_some_reasons = only_some_reasons
        self._full_name = full_name
        self._relative_name = relative_name

    def __repr__(self):
        return (
            "<IssuingDistributionPoint(full_name={0.full_name}, "
            "relative_name={0.relative_name}, "
            "only_contains_user_certs={0.only_contains_user_certs}, "
            "only_contains_ca_certs={0.only_contains_ca_certs}, "
            "only_some_reasons={0.only_some_reasons}, "
            "indirect_crl={0.indirect_crl}, "
            "only_contains_attribute_certs="
            "{0.only_contains_attribute_certs})>".format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, IssuingDistributionPoint):
            return NotImplemented

        return (
            self.full_name == other.full_name and
            self.relative_name == other.relative_name and
            self.only_contains_user_certs == other.only_contains_user_certs and
            self.only_contains_ca_certs == other.only_contains_ca_certs and
            self.only_some_reasons == other.only_some_reasons and
            self.indirect_crl == other.indirect_crl and
            self.only_contains_attribute_certs ==
            other.only_contains_attribute_certs
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((
            self.full_name,
            self.relative_name,
            self.only_contains_user_certs,
            self.only_contains_ca_certs,
            self.only_some_reasons,
            self.indirect_crl,
            self.only_contains_attribute_certs,
        ))

    full_name = utils.read_only_property("_full_name")
    relative_name = utils.read_only_property("_relative_name")
    only_contains_user_certs = utils.read_only_property(
        "_only_contains_user_certs"
    )
    only_contains_ca_certs = utils.read_only_property(
        "_only_contains_ca_certs"
    )
    only_some_reasons = utils.read_only_property("_only_some_reasons")
    indirect_crl = utils.read_only_property("_indirect_crl")
    only_contains_attribute_certs = utils.read_only_property(
        "_only_contains_attribute_certs"
    )

@utils.register_interface(ExtensionType)
class UnrecognizedExtension(object):
    def __init__(self, oid, value):
        if not isinstance(oid, ObjectIdentifier):
            raise TypeError("oid must be an ObjectIdentifier")
        self._oid = oid
        self._value = value

    oid = utils.read_only_property("_oid")
    value = utils.read_only_property("_value")

    def __repr__(self):
        return (
            "<UnrecognizedExtension(oid={0.oid}, value={0.value!r})>".format(
                self
            )
        )

    def __eq__(self, other):
        if not isinstance(other, UnrecognizedExtension):
            return NotImplemented

        return self.oid == other.oid and self.value == other.value

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.oid, self.value))

redpajama_set_name: RedPajamaGithub


The rings Claudia had been given by her grandmothers.
Claudia had been given these rings from both of her grandmothers. She wanted to have the rings melted down and remodeled into a new design, something modern that she could wear every day but also something that maintained the sentimental value of the rings.
Claudia wanted to use all the gemstones and also use the gold from the original rings.
Beginning the melting process by heating up the ingot mold.
The main challenge was the risk involved in using the original white gold. There was a potential for the metal to crack when I started re working it after it had been melted down. The really tricky thing is that you can't tell whether the metal will crack before you do it so there was going to be a financial risk involved if it didn't work and, of course, the sentimental risk of possibly losing the metal.
The other issue was with the very scratched rubies. These were very old rings and had seen a lot of wear. I suggested having them re-polished to bring them back to life. Claudia was going to lose some carat weight but I couldn't see any point in making a beautiful new ring with shabby old stones that looked worn out.
First step is to cut out the gemstones. This can take a surprising long time.
The melted down white gold forming an ingot bar.
Rolled out to form the beginnings of a ring. Black oxide build up from annealing process. (heated to soften).
The metal did indeed crack and I had to melt it twice but we were able to work around the issues. You can see a tiny crack mark in the 'Polished ring' photograph above but we were able to set one of the gemstones there so it was effectively removed. There was also a lateral crack but it was shallow and I was able to put it on the inside of the band and Claudia was happy with that.
The rubies polished up beautifully and so did the ring. Claudia now had a ring that protected her gemstones (as much as is possible), that she could wear every day, made from the original metal her grandmothers had bequeathed her.


Those who believe that 'tap and go' credit cards are the pinnacle of banking payment solutions are in for a big surprise. Chris Michael, a UK-based payments specialist and head of technology at Open Banking Limited UK, says that developments in open banking APIs could render card payments obsolete and significantly reduce levels of card fraud.
Open Banking is a non-profit organisation established to help banks comply with The UK's Competition and Market Authority (CMA) Order and Europe's second Payment Services Directive (PSD2).
Michael, who visited South Africa as a guest of Africa's largest identity-focused security provider, Ubusha Technology, held a series of discussions with local banks to discuss Open Banking and PSD2. European regulators believe that the directive will lead to a single integrated market for payment services and usher in an era of increased competition and transparency among banking and third-party financial services providers worldwide.
"Open Banking is supporting the move to PSD2 by developing a set of standards for APIs; a platform that manages the identities of banks and regulated third parties; and a suite of software and services to establish and run an open banking ecosystem," says Michael. The API standards, which sit at the heart of the open banking ecosystem, are more secure and transparent than current solutions which often rely on risky 'screen scraping' and credential sharing to access accounts and complete payments.
The open banking methodology centres on the customer's exclusive ownership of his or her data, with the customer having the final say as to which third-party providers can access this information. "A core principle of open banking is that customers do not have to share their banking credentials," says Michael. "In conjunction with the Open ID Foundation, we have developed a security model that allows them to authenticate any payment transaction using their biometric data – via their banking app – without sharing sensitive data with a third-party". The result is that customers can give third party service providers access to their bank accounts in a manner that is secure, traceable and entirely regulated.
The open banking environment will rely heavily on customer identity & access management (CIAM) to ensure that the right customer has secure and seamless access to the right applications, services & APIs. Customer identities will be secured using strong customer authentication – also referred to as multi-factor authentication.
Stakeholders in the domestic banking sector have been following market responses to PSD2 since its introduction in January 2018. "Improving customer outcomes is a key objective for banks and new Fintech firms, and those who learn from the PSD2 adoption – and the trend towards open banking solutions – will have a definite edge," comments Michael.
It is also hoped that Fintech start-ups deploying under an open banking environment will assist in meeting South Africa's financial sector transformation goals. The sharing of data between banks and third parties will remove barriers to entry and result in competitive, cost-effective solutions that will greatly improve access to financial services among lower income consumers.
"Ubusha realises the need for businesses to achieve 'secure information postures' thus allowing them to thrive in the modern era," comments Maruis Agenbag, CEO of Ubusha Technology. He adds, "Firms that launch in an open banking environment will have to combines service and software in beginning-to-end solutions that closely match customers' needs".
Ubusha is already working with banks and other large enterprises in the delivery of CIAM solutions across multiple digital channels. Its 'multi-factor customer authentication' offering will give an immediate edge to firms looking to launch into the open banking environment.
"Open banking APIs make it easier to analyse expenditures, and to provide a range of services that help people to manage their money better," concludes Michael. "In the payments space open banking APIs have the potential to replace cards and card schemes entirely – the technology is more secure, more reliable and allows financial service providers to operate at lower costs".


text:
Potomac Riverkeeper Ed Merrifield to retire; helped to found organization
By Rona Kobell on January 01, 2013
Ed Merrifield has spent nearly a decade patrolling creeks, suing polluters and challenging regulators — all in the name of restoring the Potomac River to a fishable, swimmable waterway.
But now, Merrifield, 65, says it's time to retire from the organization he helped build. He will be stepping down as Potomac Riverkeeper at the end of December. Matthew Logan, former president of the C & O Canal Trust and the Potomac Conservancy, will be taking his place.
Merrifield, a chiropractor by training who is rarely seen without his signature fisherman's cap or a Potomac Riverkeeper baseball hat, has always loved the Potomac. He helped form the Riverkeeper organization in 2000. In 2003, he stepped up to become Riverkeeper. At that time, the movement was just getting a toehold in the Chesapeake Bay region; now Riverkeepers patrol 18 of its rivers.
Merrifield preceded them all, inspired many of them, and even hired a few of them. He grew the Potomac Riverkeeper organization from a one-man band to a staff of nine, including Riverkeepers for the Shenandoah and the Upper Potomac. Volunteers swelled from a handful to a dedicated crew of 300.
Merrifield and his staff stopped illegal discharges from several sewage treatment plants in Virginia and West Virginia, forced Maryland to clean up massive lead deposits in Seneca Creek and took an active role in drafting more stringent permits for stormwater and poultry farms in all three states. He was also a major force in the eventually successful fight to make Maryland poultry farmers' nutrient management plans public.
To commemorate his retirement, U.S. Rep. Jim Moran of Virginia entered a tribute into the Congressional Record, and a flag flew over the Capitol in Merrifield's honor.
"Ed is a titan," said Chris Trumbauer, who patrols the West and Rhode rivers. "My favorite Ed line is, 'we're just trying to get to 1985' — a reference to the original time line in the Clean Water Act. Unfortunately, we're not there yet, but we're a little closer because of Ed."
People + Society
About Rona Kobell
Rona Kobell is a former writer for the Bay Journal and Baltimore Sun.
Read more articles by Rona Kobell

redpajama_set_name: RedPajamaCommonCrawl


Why Contact Flea Pest Control Melbourne Exterminator?
For healthy and wealthy life cleanness is the major step which needs to be taken by every single individual. Without any doubt we can say that in this modern lifestyle everyone is busy to fulfill their duties, hence maintaining cleanness is one of them.
So for intensive care flea pest control Melbourne, exterminators are there to sort out your queries. The experienced professionals implement the required steps for inspection as well as treatment. In certain areas, people are not aware of the threats of flea infestation. Crawling of a flea on the skin or attacking through biting are some common problems which can give rise to flea infestation.
Hence these are the blood-sucking parasites which are usually found in mammals, such as birds, cats, dogs, etc. Therefore if there are pets inside your house, then proper care is necessary to stay away from the flea. Their habitation inside your house can impact adverse effects on your family. Moreover, it can also cause some allergic reaction on your skin which is a major symptom of concerning flea pest control Melbourne service providers.
We all are aware of the fact that fleas are quite small insects; so it is not possible to examine them from naked eyes. Thus their signs on the human body or activities of your pets can only illustrate their presence.
• If your pets are scratches their body continuously; then it can be the sign of fleas infection. In such cases, it is necessary to check their furs or skin that if there is any redness in skin or not.
• The other symptom which can is the clear sign of fleas infestation is hair loss of pets. Fleas generally target the hind portion of your dog body. Therefore in case of cats neck and head are the two areas where you can find fleas.
• Flea pest control Melbourne services are there to take care of your inside as well as outside areas. The exterminators look out for pupae, larvae or eggs; which usually reside in yard or garden areas. As your pets love to roam here and there; so it's better to take care of your gardens too.
• If there are small children in your house, then it's better to pay special attention. Generally, it has been noticed that flea droppings are available in certain areas such as carpets or other sitting areas.
• So proper vacuum cleaning is recommended to make inside areas clean and healthy. If you ever observe dirt or other small insects or other things, then collect it with wet tissue and examine that if it is something like rings of blood.
Get in touch with Trusted Pest Control to control the fleas or other insects from the house. Professionals working at Trusted Pest Control are equipped to handle chemical sprays or usage of modern equipment to eradicate pests completely, and make your home infection free.


text:
No Limit Drag Racing 2
No Limit Drag Racing 2 Mod APK 1.7.0 (Unlimited money and gold)
Do you love racing so much? If you do, then download No Limit Drag Racing 2 Mod APK - Unlimited money and gold and enjoy the OG of drag racing games today. Customize your car and go for a ride.
Fun Racing Highlights of No Limit Drag Racing 2 Download No Limit Drag Racing 2 Mod APK – Unlimited Money And Gold
Information of No Limit Drag Racing 2
Last version
Battle Creek Games
Unlimited money and gold
About No Limit Drag Racing 2
There are plenty of car racing games that you can enjoy these days. If you're into car games, then you're in luck since there's so many of them right now. Car racing is one of the biggest genres today and there are many types of these games that you can enjoy. But No Limit Drag Racing 2 is a fascinating game that lets you do endless customization and races today. There are many fun races and players to go against in this game right now.
Who said that the racing genre is dead? There are many thriving racing games today and drag racing is just as popular. Enjoy countless cars today from the muscle ones, to the vintage to the faster supercars. Then, you're free to customize them however you want and change their paint, wheels, engine, rims and even add decals to them. Race your heart out now and show your driving skills to the entire world.
Racing is such an incredible activity that it has spawn many movies, shows and games today. We love racing as there are many types of cars and stunts, we can do while racing on the road. Moreover, skilled racers are paid well especially in the professional scene today where they race in front of millions. If you've always wanted to race, then this is the closest thing to real racing. No Limit Drag Racing 2 is a product of Battle Creek Games and it's full of adrenaline-pumping scenes.
This is a drag racing game which means you don't need to steer your wheels. The only thing you'll be doing is proving that you're the fastest ever by launching and shifting perfectly each time. You can face off against plenty of real opponents today that are players from all over the world. In this game, you will enjoy the purest form of racing which is drag racing. Moreover, you can collect various cars and customize them according to your liking.
You can also practice and hang out with other players online and show off.
Highlights of No Limit Drag Racing 2
Racing has been around for decades now and it's still one of the most popular genres in mobile gaming. Enjoy the original now with No Limit Drag Racing 2.
Flex Your Skills – Racing is such a pure sport that truly relies on skills more so than cars. Here, you can have the fastest car in the world but if you don't know what you're doing, you'll still lose. On the other hand, you can have a subpar car and still go toe to toe against fast ones! In No Limit Drag Racing 2, you can enjoy the original drag racing that's been around for a long time. Here, you only need to worry about shifting and starting perfectly every time.
Timing is crucial when it comes to drag racing as the winner is decided by this almost every time. You'll need to practice how to start at the perfect time and shift at the right time as well. But you'll also need to modify your engines, intakes, valve trains, tires and many more to give yourself a boost. Enjoy racing against AI and real players today.
Collect Many Cars and Customize – No Limit Drag Racing 2 has a huge collection of cars that you can buy and unlock today. From classic and vintage cars to modern ones, you will enjoy collecting many of them here. Each car has different specs and they are unique. You can then make them more unique by customizing their paint, wheels, body kits, wraps, and adding decals as well. Here, you have the opportunity to make your car look the way you want it to.
Moreover, you can upgrade your car and buy different parts such as exhausts, engine, tires, valve trains, and many more to give it more power and speed. This will allow you to go against many powerful cars.
Various Game Modes – In this game, you can enjoy the Career mode where you can earn money by racing against AI today. Then, there's the Multiplayer where you can test your skills against real players! You can also participate in daily and weekly events against the best of the best. Then, there's the Free Ride where you're free to drive your car however you want and even hang out with friends. Lastly, you can calibrate your car in the Test & Tune to see if it's up to the task.
Realistic Graphics – This game features realistic graphics and backgrounds that you'll certainly enjoy. Not only that but the sounds are realistic as well.
Download No Limit Drag Racing 2 Mod APK – Unlimited Money And Gold
Race against many players now in No Limit Drag Racing 2! Show off your customized car now.
Download No Limit Drag Racing 2 (49.27 Mb)
Discover More Interesting Games
Shell Racing
Engine Pistons ASMR
Monster Demolition
Coffee Stack
XCars Street Driving
Drift for Life
Your comment (*)
NGL
Indian Tractor Pro Simulation
Installing Guide
Copyright © 2023. Created By ModCombo.COM . All Rights Reserved
We use cookies to ensure that we give you the best experience on our website. Ok
Thanks for choosing ModCombo!
Submit page information
Include a screenshot
Game/App Name
Describe your problem
I can't download the APK file
I can't install the APK file
The file is not supported
The file doesn't exist
Upload (Document or Image)


A Tonight we have a special guest from the local establishment the Prage Café。 Welcome.
B:Hi, thanks for have a meal on your show.
B:Well, since people we have rabbits wandering freely on the place; our customers come in and enjoy their food and drinks, while a little rabbit playing on their legs. There is no other place like it.
B:So we thought why not rabbit? People love the rabbits, they are very cute animals.
B:It is perfectly safe both for rabbits and our customers. Rabbits are very peaceful and safe. They don't bite. Our rabbits are regularly cleaned. So there is no risks ever. And as for our customers,they are all animals lovers. We will never try to hurt the rabbits. Sometimes some young child may get over excited and be a little too rough. But is never a serious matter. On the contrary, the café is a great experience for children. A chance they learn how to take care of the animals.
A:Well it is certainly the first time I heard of a café like that.
W:Oh,hi. I'm great,thanks. And you look great too.
M: Thank you. It's good to see you shopping in the organic section. I see you got a lot of healthy stuff. I wish I could buy more organic produce from here. But I find that kids don't like it. I don't know about yours, but mine are all about junk food.
W:Oh,trust me. I know exactly how you feel. My children are the same. What is it with kids these days that all like junk food they eat. I think it's all that advertising on TV. That's where they get it.
M:Yes,it must be. My children see something on TV and they immediately want it. It's like they don't realize it's just an advertisement.
W:Right,and practically everything that advertises for children is unhealthy processed food. No surprise then,it becomes a battle for us parents to feed our children ordinary food and vegetables.
M: That's just the thing. One never sees ordinary ingredients being advertised on TV. It's never a carrot or a peach,it's always some garbage like chocolate covered sweets. So unhealthy.
W:Exactly. And these big food cooperations have so much money to spend on clever tactic design to make young people want to buy their products. Children never stand the chance,it's really not fair.
M:You are so right. When we were children,we barely had any junk food available and we turned out just fine.
W: Yes, my parents don't understand any of it. Both TV commercials and the supermarkets are alien to them. Their worlds were so different back to when they are young.
M: I don't know what will happen to the next generation.
W: The world is going crazy.
At some 2300 miles in length,the Mississippi is the longest river in the United States. At some 1000 miles,the Mackenzie is the longest river in Canada. But these waterways seem mute in comparison to the world's two longest rivers —— the Nile and the Amazon. The Nile,which begins in central Africa and flows over 4100 miles north into the Mediterranean. Host to one of the world's great ancient civilizations along its shores,Calm and peaceful for most of the year, the Nile used to flood annually. Their by creating,irrigating and caring new top soil to the nearby farmland on which ancient Egypt depended for a livelihood. As a means of transportation,the river carried various vessels up and down its length. A journey through the unconstructed part of this waterway today would pass by the splendid valley of the kings with tombs of many of these ancient monarchs,having stood for over 3000 years. Great civilizations and intensive settlements are hardly associated with the Amazon. Yet this 4000 mile-long south American river carries about 20% of the world's fresh water,more than the Mississippi,Nile and the Mackenzie combined. Other statistics are equally astonishing. the Amazon is so wide at some points that from its center neither shore can be seen. Each second the Amazon pours some 55 million gallons of water into the Atlantic. There,at it's mouth stands one island larger than Switzland. Most important of all,the Amazon irrigates the largest tropical rainforest on earth.
How often do you say to people "I'm busy" or "I haven't got time for that." It's inevitable true that all of us live a life in the far slain,even though we know that being busy is not always particular healthy. Growing-up in New Zealand,everything was always calm and slow,people enjoy the tranquility of a slower pace of life. After I moved to the Tokyo and lived there in a number of years,I got used to having a pilot to do lists. And my calendar always looks like a mass with lots of things to do. Return across it,I found myself feeling my timer with endless work meetings in social events. Russian along as busy as it be. Then,one day,I came across a book, called in praise of slowness and realized that being busy is not only detrimental, but also has the danger of turning life into endless race. So I started practicing various practical steps, mentioned by the author of the book,and began to revolt against every idea of being too busy. It doesn't mean that to do lists no longer exist,but I become more aware of the important of slowing down and making sure that I enjoy the daily activities as I care about. From now on,when someone asked how your life is,try your responding with the words like "exciting and fun",instead of the culture norm that says busy. Say if your experience that tranquility that follows.
Government's private groups and indivisuals spend billions of dollars a year trying to route out non-native organisms that are considered dangerous to ecosystems and to prevent the introduction of new intruders.
But a number of scientists question the assumption that the presence of alien species can nevr be acceptable in a natural ecosystem.
They say that portraying introduced species as inherently bad is an unscientific approach. "Distinctions between exotic and native species are artificial",said Dr. Michael Rosenspeek, a professor of evolutionary biology at the University of Arizona.
Ecosystems free of species to find as exotic are by default consider the most natural.
At its core, the debate is about how to manage the world's remaining natural ecosystems and how and how much to restore other habitats.
Species that invade a territory can harm ecosystems,agriculture and human health.
They can threaten some native species or even destroy and replace others.
Next habitat loss,these evasive species represents the greatest threat to bio-diversity worldwide, many ecologists say.
Ecologists generally define an alien species as one that people accidentally or deliberately carried to its new location.
Across the American continents,exotic species are those introduced after the first European contact.
That date rounded of to 15 AD, represents what ecologist considered to have been a major shift in the spread of species including crops and life stock as they began to migrate with humans from continent to continent.
"Only a small percentage of alien species calls problems in their new habitats,"said Don Smith,professor of ecology and evolutionary biology at the Univiersity of Tenacy.
Good morning,ladies and gentlemen. And welcome to the third in our cities of business seminars in the program doing business abroad. 19.Today we are going to look for different culture awareness. That is the fact that not everyone is in British. Not everyone speaks in English and not everyone does business in the British way. And why should they?If overseas business people are selling to us and they will make every effort to speak English and to expect our tradition methods. It is only polite for us to do the same when we visit them. It is not only polite but it is central if we want to sell British projects overseas.
Okay,everyone has the chance to make some notes. Right,here are the answers. Although I'm sure the information could equally well apply to countries other than your chosen. So No.1 , you must long drink alcohol in the first and second in Indian. 20.And in that hotels you may find that served but if you had a meal with an Indian colleague. Remember to avoid asking for a beer. No.2 ,In other countries,the politeness in general society is that people without power all. If you admire your colleague beautiful golden bowls you may well find yourself being present with them .This is not the cheat yourself way,however,as your host will find the equal words and beauty. In Thailand,keeping the fingers clapping your hands or shouting at the waiter will embarrass your hosts,fellow diners,waiter himself most of all-you.Place you palm down to make an implicit gesture and sacrificing the results,21.And finally,in Spain, some businesses may stay working until 2 o'clock and returning to the office from 5:30 to 8 or 9 in the evening.
Shortly after he took over the Reader's Digest Association in 1984, George Grune unlocked the company's boardroom and announced that the room was now open to the employees. It was a symbolic act,indicating that under Grune's leadership,Reader's Digest was going to be different. True to his word,Grune has shaken up the culture here. To get an idea of the culture we're talking about,consider the boardroom Grune opened up,it has artworks that any museum in the world would want to collect,paintings by many world famous artists like Monet and Picasso.
Its headquarters'houses sum 3,000 works of art.The Main building is topped with a Georgian Tower with four sculptures of the mythical winged horse, the magazine corporate logo. It sits on 127 acres of well trimmed lawns. The editor's office used to be occupied by founder Dewitt Wallace, who along with his wife Lila Acheson Wallace, launched Reader's Digest in 1922 with condensed articles from other publications.It has become the world's most widely read magazine,selling 28 million copies each month in 17 languages and 41 different editions. The Wallaces,both children of church ministers,had a clearly defined formula for their little magazine. As Reader's Digest was originally subtitled,articles were to be short,readable and uplifting. Subjects were picked to inspire or entertain. The Wallaces didn't accept advertising in the US edition until 1955 and even then they didn't allow any ads for cigarettes,liquor or drugs. The Wallaces also had a clear sense of the kind of workplace they wanted. It started as a mama and papa operation and the childless Wallaces always considered employees to be part of their family.Employees still tell stories of how the Wallaces would take care of their employees who had met with misfortunes and they showered their employees with unusual benefits like a turkey on Thanksgiving and Fridays off in May. This cozy workplace is no longer exists here.The Wallaces both died in their nineties in the early 1981s. George Grune,a former ad salesman who joined Reader's Digest in 1960 has his eyes focused on the bottom line. In a few short years, he turned the magazine on its head, he laid off several hundred workers,especially hard hit where the blue and paint color departments such as subscription fulfillment.
Directions: In this section, there is a passage with ten blanks. You are required to select one word for each blank from a list of choices given in a word bank following the passage. Read the passage through carefully before making your choices. Each choice in the bank is identified by a letter. Please mark the corresponding letter for each item on Answer Sheet 2 with a single line through the centre. You may not use any of the words in the bank more than once.
Did Sarah Josepha Hale write "Mary's Little Lamb," the eternal nursery rhyme (儿歌) about girl named Mary with a stubborn lamb? This is still disputed, but it's clear that the woman __26__ for writing it was one of America's most fascinating __27 __. In honor of the poem publication on May 24,1830, here's more about the __28__ author's life.
Hale wasn't just a writer, she was also a __29__ social advocate, and she was particularly __30__ with an ideal New England, which she associated with abundant Thanksgiving meals that she claimed had "a deep moral influence," she began a nationwide __31__ to have a national holiday declared that would bring families together while celebrating the __32__ festivals. In 1863, after 17 years of advocacy including letters to five presidents, Hale got it. President Abraham Lincoln during the Civil War, issued a __33__ setting aside the last Thursday in November for the holiday.
Bicycles were once the most important vehicles in both urban and rural areas of China. That's why China was once called the "bike kingdom." Nowadays, as the problem of urban traffic congestion and air pollution growsincreasingly serious, bicycle riding has become popular again. Recently, through combining mobile Internet technology with traditional bicycles, Chinese entrepreneurs have created an industry known as "bicycle-sharing". People can use a shared bicycle at any time with only one mobile phone, which allows cycling more convenient. Many cities have built bicycle lanes in order to encourage people to cycle. Now, more and more Chinese people also like to exercise by cycling.


The selection of courses and programs in secondary school depends on a partnership between students, parents the school and the community. While the new Secondary School program that began in September 1999 is a four-year program of study please note that there is no Ministry of Education requirement stating that students must finish their secondary school program in four years. The Hamilton-Wentworth Catholic District School Board encourages students to plan their high school curriculum/pathway in such a manner that will maximize achievement, post-secondary opportunities and personal satisfaction. Many students may find that four and a half or five years of secondary school are required.
and administrators can provide valuable assistance in all matters related to course selection, program and career planning. Students and parents are encouraged to seek advice and assistance from these professionals.
Not all courses listed in this calendar are available at every school. School option sheets indicate what courses are offered at each school in each program area. Students and parents should note that course offerings are subject to enrolment.


Cable television is a process of allocating television programs to offer subscribers through radio frequency indicators broadcasted through coaxial cables via fiber optic cables. This disparity with custom broadcast television in which the TV signal is broadcasted over the air with the help of radio waves and conventional by Television antenna connected to the TV. FM radio programming fastest speed, telephone facility, fastest internet and parallel non-television services perhaps also offered via these cables. The development of Cable TV initially started from Asia side then spread all over the world. Coming towards Broadcasting than it is the allocation of video and audio content to a isolated viewers through visible mass communication standard and audio except one using electromagnetic waves. Broadcasting has been generally used for the non-commercial replacement of messages, urgent situation communication like Amateur Television, personal recreation by adding to commercial objectives such as, Radio or TV stations with marketing. Moreover, the beginning of cable broadcasting is even historic as radio encoding was circulated by cable in few cities of Europe in 1924.The word Broadcast was first used by radio engineers in the past from Midwestern United States indulging transmit sowing as a symbol for the scattering inherent in unidirectional radio indications. This term is huge and momentous segment of the mass media. Broadcasting is actually tranquil of analog by means of analog diffusion methods and more freshly broadcasters have toggled to digital indicators by using digital diffusion.
Recently, TV stations in East of Ukraine possessed Radio Free Europe and Radio emancipation and Voice of American encoding have been enforced off the air with accordance to the Broadcasting Board of Governors which supervise the programming. On 12th May, BBG stated that Armed Russian Speaking enforced workers off a radio place in Donetsk associated with RFE/RL. This pursues an attack on RFE/RLL members while casing a revelation in Kharkiv on 1st May. Additionally, VOA stated that Ukraine has missing its indicating signals in Donetsk and Luhansk plus carious cable suppliers have been terrified. On 2nd May, various men with weapons endangered VOA video casters in Donetsk, whereas other VOA reporter was given a warning that he had been objectify got imprison. Beside of Dangerous atmosphere still VOA and RFE/RL are offering enough data and new information according to people needs.
However, present stock rating in Broadcasting and Cable TV recorded as 10.47% with an affirmative change. On the other hand, net income growth statics shows positive result i.e. 775.91%. Furthermore, in case of any query regarding stock information than visit Bidnessetc.com right now. Basically this website is one of best platform that offer latest news and information regarding stock rating of different companies and organizations within just two clicks.