Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface ENS
•    - function setRecord(bytes32 node, addr ...
•    - function setSubnodeRecord(bytes32 nod ...
•    - function setSubnodeOwner(bytes32 node ...
•    - function setResolver(bytes32 node, ad ...
•    - function setOwner(bytes32 node, addre ...
•    - function setTTL(bytes32 node, uint64 ...
•    - function setApprovalForAll(address op ...
•    - function owner(bytes32 node)
•    - function resolver(bytes32 node)
•    - function ttl(bytes32 node)
•    - function recordExists(bytes32 node)
•    - function isApprovedForAll(address own ...
• interface PriceOracle
•    - function price(string calldata name, ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•  contract IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•  contract Ownable
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract BaseRegistrar is IERC721, ...
•    - function addController(address contro ...
•    - function removeController(address con ...
•    - function setResolver(address resolver ...
•    - function nameExpires(uint256 id)
•    - function available(uint256 id)
•    - function register(uint256 id, address ...
•    - function renew(uint256 id, uint durat ...
•    - function reclaim(uint256 id, address ...
• library StringUtils
•    - function strlen(string memory s)
• interface Resolver
•    - function ABI(bytes32 node, uint256 co ...
•    - function addr(bytes32 node)
•    - function addr(bytes32 node, uint coin ...
•    - function contenthash(bytes32 node)
•    - function dnsrr(bytes32 node)
•    - function name(bytes32 node)
•    - function pubkey(bytes32 node)
•    - function text(bytes32 node, string ca ...
•    - function interfaceImplementer(bytes32 ...
•    - function setABI(bytes32 node, uint256 ...
•    - function setAddr(bytes32 node, addres ...
•    - function setAddr(bytes32 node, uint c ...
•    - function setContenthash(bytes32 node, ...
•    - function setDnsrr(bytes32 node, bytes ...
•    - function setName(bytes32 node, string ...
•    - function setPubkey(bytes32 node, byte ...
•    - function setText(bytes32 node, string ...
•    - function setInterface(bytes32 node, b ...
•    - function supportsInterface(bytes4 int ...
•    - function content(bytes32 node)
•    - function multihash(bytes32 node)
•    - function setContent(bytes32 node, byt ...
•    - function setMultihash(bytes32 node, b ...
•  contract ETHRegistrarController is ...
•    - function rentPrice(string memory name ...
•    - function valid(string memory name)
•    - function available(string memory name ...
•    - function makeCommitment(string memory ...
•    - function makeCommitmentWithConfig(str ...
•    - function commit(bytes32 commitment)
•    - function register(string calldata nam ...
•    - function registerWithConfig(string me ...
•    - function renew(string calldata name, ...
•    - function setPriceOracle(PriceOracle _ ...
•    - function setCommitmentAges(uint _minC ...
•    - function withdraw()
•    - function supportsInterface(bytes4 int ...
•    - function _consumeCommitment(string me ...
•  contract BulkRenewal *
•    - function getController()
•    - function rentPrice(string[] calldata ...
•    - function renewAll(string[] calldata n ...
•    - function supportsInterface(bytes4 int ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-04-28
*/

// File: @ensdomains/ens/contracts/ENS.sol

pragma solidity >=0.4.24;

interface ENS {

    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);

    // Logged when an operator is added or removed.
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;
    function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external;
    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns(bytes32);
    function setResolver(bytes32 node, address resolver) external;
    function setOwner(bytes32 node, address owner) external;
    function setTTL(bytes32 node, uint64 ttl) external;
    function setApprovalForAll(address operator, bool approved) external;
    function owner(bytes32 node) external view returns (address);
    function resolver(bytes32 node) external view returns (address);
    function ttl(bytes32 node) external view returns (uint64);
    function recordExists(bytes32 node) external view returns (bool);
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: contracts/PriceOracle.sol

pragma solidity >=0.4.24;

interface PriceOracle {
    /**
     * @dev Returns the price to register or renew a name.
     * @param name The name being registered or renewed.
     * @param expires When the name presently expires (0 if this is a new registration).
     * @param duration How long the name is being registered or extended for, in seconds.
     * @return The price of this renewal or registration, in wei.
     */
    function price(string calldata name, uint expires, uint duration) external view returns(uint);
}

// File: openzeppelin-solidity/contracts/introspection/IERC165.sol

pragma solidity >=0.5.0;

/**
 * @title IERC165
 * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
 */
interface IERC165 {
    /**
     * @notice Query if a contract implements an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @dev Interface identification is specified in ERC-165. This function
     * uses less than 30,000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: openzeppelin-solidity/contracts/token/ERC721/IERC721.sol

pragma solidity >=0.5.0;


/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function balanceOf(address owner) public view returns (uint256 balance);
    function ownerOf(uint256 tokenId) public view returns (address owner);

    function approve(address to, uint256 tokenId) public;
    function getApproved(uint256 tokenId) public view returns (address operator);

    function setApprovalForAll(address operator, bool _approved) public;
    function isApprovedForAll(address owner, address operator) public view returns (bool);

    function transferFrom(address from, address to, uint256 tokenId) public;
    function safeTransferFrom(address from, address to, uint256 tokenId) public;

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

pragma solidity >=0.5.0;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @return the address of the owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner());
        _;
    }

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * @notice Renouncing to ownership will leave the contract without an owner.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/BaseRegistrar.sol

pragma solidity >=0.4.24;




contract BaseRegistrar is IERC721, Ownable {
    uint constant public GRACE_PERIOD = 90 days;

    event ControllerAdded(address indexed controller);
    event ControllerRemoved(address indexed controller);
    event NameMigrated(uint256 indexed id, address indexed owner, uint expires);
    event NameRegistered(uint256 indexed id, address indexed owner, uint expires);
    event NameRenewed(uint256 indexed id, uint expires);

    // The ENS registry
    ENS public ens;

    // The namehash of the TLD this registrar owns (eg, .eth)
    bytes32 public baseNode;

    // A map of addresses that are authorised to register and renew names.
    mapping(address=>bool) public controllers;

    // Authorises a controller, who can register and renew domains.
    function addController(address controller) external;

    // Revoke controller permission for an address.
    function removeController(address controller) external;

    // Set the resolver for the TLD this registrar manages.
    function setResolver(address resolver) external;

    // Returns the expiration timestamp of the specified label hash.
    function nameExpires(uint256 id) external view returns(uint);

    // Returns true iff the specified name is available for registration.
    function available(uint256 id) public view returns(bool);

    /**
     * @dev Register a name.
     */
    function register(uint256 id, address owner, uint duration) external returns(uint);

    function renew(uint256 id, uint duration) external returns(uint);

    /**
     * @dev Reclaim ownership of a name in ENS, if you own it in the registrar.
     */
    function reclaim(uint256 id, address owner) external;
}

// File: contracts/StringUtils.sol

pragma solidity >=0.4.24;

library StringUtils {
    /**
     * @dev Returns the length of a given string
     *
     * @param s The string to measure the length of
     * @return The length of the input string
     */
    function strlen(string memory s) internal pure returns (uint) {
        uint len;
        uint i = 0;
        uint bytelength = bytes(s).length;
        for(len = 0; i < bytelength; len++) {
            byte b = bytes(s)[i];
            if(b < 0x80) {
                i += 1;
            } else if (b < 0xE0) {
                i += 2;
            } else if (b < 0xF0) {
                i += 3;
            } else if (b < 0xF8) {
                i += 4;
            } else if (b < 0xFC) {
                i += 5;
            } else {
                i += 6;
            }
        }
        return len;
    }
}

// File: @ensdomains/resolver/contracts/Resolver.sol

pragma solidity >=0.4.25;

/**
 * A generic resolver interface which includes all the functions including the ones deprecated
 */
interface Resolver{
    event AddrChanged(bytes32 indexed node, address a);
    event AddressChanged(bytes32 indexed node, uint coinType, bytes newAddress);
    event NameChanged(bytes32 indexed node, string name);
    event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
    event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
    event TextChanged(bytes32 indexed node, string indexed indexedKey, string key);
    event ContenthashChanged(bytes32 indexed node, bytes hash);
    /* Deprecated events */
    event ContentChanged(bytes32 indexed node, bytes32 hash);

    function ABI(bytes32 node, uint256 contentTypes) external view returns (uint256, bytes memory);
    function addr(bytes32 node) external view returns (address);
    function addr(bytes32 node, uint coinType) external view returns(bytes memory);
    function contenthash(bytes32 node) external view returns (bytes memory);
    function dnsrr(bytes32 node) external view returns (bytes memory);
    function name(bytes32 node) external view returns (string memory);
    function pubkey(bytes32 node) external view returns (bytes32 x, bytes32 y);
    function text(bytes32 node, string calldata key) external view returns (string memory);
    function interfaceImplementer(bytes32 node, bytes4 interfaceID) external view returns (address);

    function setABI(bytes32 node, uint256 contentType, bytes calldata data) external;
    function setAddr(bytes32 node, address addr) external;
    function setAddr(bytes32 node, uint coinType, bytes calldata a) external;
    function setContenthash(bytes32 node, bytes calldata hash) external;
    function setDnsrr(bytes32 node, bytes calldata data) external;
    function setName(bytes32 node, string calldata _name) external;
    function setPubkey(bytes32 node, bytes32 x, bytes32 y) external;
    function setText(bytes32 node, string calldata key, string calldata value) external;
    function setInterface(bytes32 node, bytes4 interfaceID, address implementer) external;

    function supportsInterface(bytes4 interfaceID) external pure returns (bool);

    /* Deprecated functions */
    function content(bytes32 node) external view returns (bytes32);
    function multihash(bytes32 node) external view returns (bytes memory);
    function setContent(bytes32 node, bytes32 hash) external;
    function setMultihash(bytes32 node, bytes calldata hash) external;
}

// File: contracts/ETHRegistrarController.sol

pragma solidity >=0.5.0;






/**
 * @dev A registrar controller for registering and renewing names at fixed cost.
 */
contract ETHRegistrarController is Ownable {
    using StringUtils for *;

    uint constant public MIN_REGISTRATION_DURATION = 28 days;

    bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
    bytes4 constant private COMMITMENT_CONTROLLER_ID = bytes4(
        keccak256("rentPrice(string,uint256)") ^
        keccak256("available(string)") ^
        keccak256("makeCommitment(string,address,bytes32)") ^
        keccak256("commit(bytes32)") ^
        keccak256("register(string,address,uint256,bytes32)") ^
        keccak256("renew(string,uint256)")
    );

    bytes4 constant private COMMITMENT_WITH_CONFIG_CONTROLLER_ID = bytes4(
        keccak256("registerWithConfig(string,address,uint256,bytes32,address,address)") ^
        keccak256("makeCommitmentWithConfig(string,address,bytes32,address,address)")
    );

    BaseRegistrar base;
    PriceOracle prices;
    uint public minCommitmentAge;
    uint public maxCommitmentAge;

    mapping(bytes32=>uint) public commitments;

    event NameRegistered(string name, bytes32 indexed label, address indexed owner, uint cost, uint expires);
    event NameRenewed(string name, bytes32 indexed label, uint cost, uint expires);
    event NewPriceOracle(address indexed oracle);

    constructor(BaseRegistrar _base, PriceOracle _prices, uint _minCommitmentAge, uint _maxCommitmentAge) public {
        require(_maxCommitmentAge > _minCommitmentAge);

        base = _base;
        prices = _prices;
        minCommitmentAge = _minCommitmentAge;
        maxCommitmentAge = _maxCommitmentAge;
    }

    function rentPrice(string memory name, uint duration) view public returns(uint) {
        bytes32 hash = keccak256(bytes(name));
        return prices.price(name, base.nameExpires(uint256(hash)), duration);
    }

    function valid(string memory name) public pure returns(bool) {
        return name.strlen() >= 3;
    }

    function available(string memory name) public view returns(bool) {
        bytes32 label = keccak256(bytes(name));
        return valid(name) && base.available(uint256(label));
    }

    function makeCommitment(string memory name, address owner, bytes32 secret) pure public returns(bytes32) {
        return makeCommitmentWithConfig(name, owner, secret, address(0), address(0));
    }

    function makeCommitmentWithConfig(string memory name, address owner, bytes32 secret, address resolver, address addr) pure public returns(bytes32) {
        bytes32 label = keccak256(bytes(name));
        if (resolver == address(0) && addr == address(0)) {
            return keccak256(abi.encodePacked(label, owner, secret));
        }
        require(resolver != address(0));
        return keccak256(abi.encodePacked(label, owner, resolver, addr, secret));
    }

    function commit(bytes32 commitment) public {
        require(commitments[commitment] + maxCommitmentAge < now);
        commitments[commitment] = now;
    }

    function register(string calldata name, address owner, uint duration, bytes32 secret) external payable {
      registerWithConfig(name, owner, duration, secret, address(0), address(0));
    }

    function registerWithConfig(string memory name, address owner, uint duration, bytes32 secret, address resolver, address addr) public payable {
        bytes32 commitment = makeCommitmentWithConfig(name, owner, secret, resolver, addr);
        uint cost = _consumeCommitment(name, duration, commitment);

        bytes32 label = keccak256(bytes(name));
        uint256 tokenId = uint256(label);

        uint expires;
        if(resolver != address(0)) {
            // Set this contract as the (temporary) owner, giving it
            // permission to set up the resolver.
            expires = base.register(tokenId, address(this), duration);

            // The nodehash of this label
            bytes32 nodehash = keccak256(abi.encodePacked(base.baseNode(), label));

            // Set the resolver
            base.ens().setResolver(nodehash, resolver);

            // Configure the resolver
            if (addr != address(0)) {
                Resolver(resolver).setAddr(nodehash, addr);
            }

            // Now transfer full ownership to the expeceted owner
            base.reclaim(tokenId, owner);
            base.transferFrom(address(this), owner, tokenId);
        } else {
            require(addr == address(0));
            expires = base.register(tokenId, owner, duration);
        }

        emit NameRegistered(name, label, owner, cost, expires);

        // Refund any extra payment
        if(msg.value > cost) {
            msg.sender.transfer(msg.value - cost);
        }
    }

    function renew(string calldata name, uint duration) external payable {
        uint cost = rentPrice(name, duration);
        require(msg.value >= cost);

        bytes32 label = keccak256(bytes(name));
        uint expires = base.renew(uint256(label), duration);

        if(msg.value > cost) {
            msg.sender.transfer(msg.value - cost);
        }

        emit NameRenewed(name, label, cost, expires);
    }

    function setPriceOracle(PriceOracle _prices) public onlyOwner {
        prices = _prices;
        emit NewPriceOracle(address(prices));
    }

    function setCommitmentAges(uint _minCommitmentAge, uint _maxCommitmentAge) public onlyOwner {
        minCommitmentAge = _minCommitmentAge;
        maxCommitmentAge = _maxCommitmentAge;
    }

    function withdraw() public onlyOwner {
        msg.sender.transfer(address(this).balance);
    }

    function supportsInterface(bytes4 interfaceID) external pure returns (bool) {
        return interfaceID == INTERFACE_META_ID ||
               interfaceID == COMMITMENT_CONTROLLER_ID ||
               interfaceID == COMMITMENT_WITH_CONFIG_CONTROLLER_ID;
    }

    function _consumeCommitment(string memory name, uint duration, bytes32 commitment) internal returns (uint256) {
        // Require a valid commitment
        require(commitments[commitment] + minCommitmentAge <= now);

        // If the commitment is too old, or the name is registered, stop
        require(commitments[commitment] + maxCommitmentAge > now);
        require(available(name));

        delete(commitments[commitment]);

        uint cost = rentPrice(name, duration);
        require(duration >= MIN_REGISTRATION_DURATION);
        require(msg.value >= cost);

        return cost;
    }
}

// File: contracts/BulkRenewal.sol

pragma solidity >=0.5.0;
pragma experimental ABIEncoderV2;




contract BulkRenewal {
    bytes32 constant private ETH_NAMEHASH = 0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae;
    bytes4 constant private REGISTRAR_CONTROLLER_ID = 0x018fac06;
    bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
    bytes4 constant public BULK_RENEWAL_ID = bytes4(
        keccak256("rentPrice(string[],uint)") ^
        keccak256("renewAll(string[],uint")
    );

    ENS public ens;

    constructor(ENS _ens) public {
        ens = _ens;
    }

    function getController() internal view returns(ETHRegistrarController) {
        Resolver r = Resolver(ens.resolver(ETH_NAMEHASH));
        return ETHRegistrarController(r.interfaceImplementer(ETH_NAMEHASH, REGISTRAR_CONTROLLER_ID));
    }

    function rentPrice(string[] calldata names, uint duration) external view returns(uint total) {
        ETHRegistrarController controller = getController();
        for(uint i = 0; i < names.length; i++) {
            total += controller.rentPrice(names[i], duration);
        }
    }

    function renewAll(string[] calldata names, uint duration) external payable {
        ETHRegistrarController controller = getController();
        for(uint i = 0; i < names.length; i++) {
            uint cost = controller.rentPrice(names[i], duration);
            controller.renew.value(cost)(names[i], duration);
        }
        // Send any excess funds back
        msg.sender.transfer(address(this).balance);
    }

    function supportsInterface(bytes4 interfaceID) external pure returns (bool) {
         return interfaceID == INTERFACE_META_ID || interfaceID == BULK_RENEWAL_ID;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract ENS","name":"_ens","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"constant":true,"inputs":[],"name":"BULK_RENEWAL_ID","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"ens","outputs":[{"internalType":"contract ENS","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"string[]","name":"names","type":"string[]"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"renewAll","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"internalType":"string[]","name":"names","type":"string[]"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"rentPrice","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes4","name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"pure","type":"function"}]

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

00000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e

-----Decoded View---------------
Arg [0] : _ens (address): 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e

18570:1706:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20104:169;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20104:169:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;19372:288;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19372:288:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;19033:14;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19033:14:0;;;:::i;:::-;;;;;;;;;;;;;;;;18875:149;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18875:149:0;;;:::i;:::-;;;;;;;;;;;;;;;;19668:428;;;;;;;;;;;;;;;;:::i;:::-;;20104:169;20174:4;18829:38;;;;;;;;;;;;;;20199:32;;;:11;:32;;;;:66;;;;18982:35;;;;;;;;;;;;;;18933:37;;;;;;;;;;;;;;:84;20235:30;;;:11;:30;;;;20199:66;20192:73;;20104:169;;;:::o;19372:288::-;19453:10;19476:33;19512:15;:13;:15::i;:::-;19476:51;;19542:6;19551:1;19542:10;;19538:115;19558:5;;:12;;19554:1;:16;19538:115;;;19601:10;:20;;;19622:5;;19628:1;19622:8;;;;;;;;;;;;;43:11:-1;30:25;137:1;131:4;127:12;116:8;100:14;96:29;92:48;72:18;68:73;58:2;;155:1;152;145:12;58:2;188:18;178:8;174:33;162:45;;0:210;29:8;16:22;6:32;;69:4;59:8;55:19;43:31;;93:18;85:6;82:30;79:2;;;125:1;122;115:12;79:2;183:4;175:6;171:17;155:14;151:38;141:8;137:53;134:2;;;203:1;200;193:12;134:2;19632:8:0;19601:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19601:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19601:40:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;19601:40:0;;;;;;;;;19592:49;;;;19572:3;;;;;;;19538:115;;;;19372:288;;;;;;:::o;19033:14::-;;;;;;;;;;;;;:::o;18875:149::-;18982:35;;;;;;;;;;;;;;18933:37;;;;;;;;;;;;;;:84;18875:149;:::o;19668:428::-;19754:33;19790:15;:13;:15::i;:::-;19754:51;;19820:6;19829:1;19820:10;;19816:181;19836:5;;:12;;19832:1;:16;19816:181;;;19870:9;19882:10;:20;;;19903:5;;19909:1;19903:8;;;;;;;;;;;;;43:11:-1;30:25;137:1;131:4;127:12;116:8;100:14;96:29;92:48;72:18;68:73;58:2;;155:1;152;145:12;58:2;188:18;178:8;174:33;162:45;;0:210;29:8;16:22;6:32;;69:4;59:8;55:19;43:31;;93:18;85:6;82:30;79:2;;;125:1;122;115:12;79:2;183:4;175:6;171:17;155:14;151:38;141:8;137:53;134:2;;;203:1;200;193:12;134:2;19913:8:0;19882:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19882:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19882:40:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;19882:40:0;;;;;;;;;19870:52;;19937:10;:16;;;19960:4;19966:5;;19972:1;19966:8;;;;;;;;;;;;;43:11:-1;30:25;137:1;131:4;127:12;116:8;100:14;96:29;92:48;72:18;68:73;58:2;;155:1;152;145:12;58:2;188:18;178:8;174:33;162:45;;0:210;29:8;16:22;6:32;;69:4;59:8;55:19;43:31;;93:18;85:6;82:30;79:2;;;125:1;122;115:12;79:2;183:4;175:6;171:17;155:14;151:38;141:8;137:53;134:2;;;203:1;200;193:12;134:2;19976:8:0;19937:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19937:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19937:48:0;;;;;19816:181;19850:3;;;;;;;19816:181;;;;20046:10;:19;;:42;20066:21;20046:42;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;20046:42:0;19668:428;;;;:::o;19122:242::-;19169:22;19204:10;19226:3;;;;;;;;;;;:12;;;18638:66;19239:12;;19226:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19226:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19226:26:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;19226:26:0;;;;;;;;;19204:49;;19294:1;:22;;;18638:66;19317:12;;18761:10;19331:23;;19294:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19294:61:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19294:61:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;19294:61:0;;;;;;;;;19264:92;;;19122:242;:::o;5:134:-1:-;;89:6;83:13;74:22;;101:33;128:5;101:33;;;68:71;;;;;163:360;;;301:3;294:4;286:6;282:17;278:27;268:2;;319:1;316;309:12;268:2;352:6;339:20;329:30;;379:18;371:6;368:30;365:2;;;411:1;408;401:12;365:2;445:4;437:6;433:17;421:29;;496:3;488:4;480:6;476:17;466:8;462:32;459:41;456:2;;;513:1;510;503:12;456:2;261:262;;;;;;531:128;;610:6;597:20;588:29;;622:32;648:5;622:32;;;582:77;;;;;666:130;;746:6;733:20;724:29;;758:33;785:5;758:33;;;718:78;;;;;803:134;;887:6;881:13;872:22;;899:33;926:5;899:33;;;866:71;;;;;944:263;;1059:2;1047:9;1038:7;1034:23;1030:32;1027:2;;;1075:1;1072;1065:12;1027:2;1110:1;1127:64;1183:7;1174:6;1163:9;1159:22;1127:64;;;1117:74;;1089:108;1021:186;;;;;1214:538;;;;1378:2;1366:9;1357:7;1353:23;1349:32;1346:2;;;1394:1;1391;1384:12;1346:2;1457:1;1446:9;1442:17;1429:31;1480:18;1472:6;1469:30;1466:2;;;1512:1;1509;1502:12;1466:2;1540:88;1620:7;1611:6;1600:9;1596:22;1540:88;;;1530:98;;;;1408:226;1665:2;1683:53;1728:7;1719:6;1708:9;1704:22;1683:53;;;1673:63;;1644:98;1340:412;;;;;;1759:239;;1862:2;1850:9;1841:7;1837:23;1833:32;1830:2;;;1878:1;1875;1868:12;1830:2;1913:1;1930:52;1974:7;1965:6;1954:9;1950:22;1930:52;;;1920:62;;1892:96;1824:174;;;;;2005:263;;2120:2;2108:9;2099:7;2095:23;2091:32;2088:2;;;2136:1;2133;2126:12;2088:2;2171:1;2188:64;2244:7;2235:6;2224:9;2220:22;2188:64;;;2178:74;;2150:108;2082:186;;;;;2275:104;2352:21;2367:5;2352:21;;;2347:3;2340:34;2334:45;;;2386:113;2469:24;2487:5;2469:24;;;2464:3;2457:37;2451:48;;;2506:110;2587:23;2604:5;2587:23;;;2582:3;2575:36;2569:47;;;2623:148;2717:48;2759:5;2717:48;;;2712:3;2705:61;2699:72;;;2803:296;;2915:71;2979:6;2974:3;2915:71;;;2908:78;;2998:43;3034:6;3029:3;3022:5;2998:43;;;3063:29;3085:6;3063:29;;;3058:3;3054:39;3047:46;;2901:198;;;;;;3108:361;;3286:85;3368:2;3363:3;3286:85;;;3279:92;;3404:27;3400:1;3395:3;3391:11;3384:48;3460:2;3455:3;3451:12;3444:19;;3272:197;;;;3478:360;;3656:85;3738:2;3733:3;3656:85;;;3649:92;;3774:26;3770:1;3765:3;3761:11;3754:47;3829:2;3824:3;3820:12;3813:19;;3642:196;;;;3847:358;;4025:85;4107:2;4102:3;4025:85;;;4018:92;;4143:24;4139:1;4134:3;4130:11;4123:45;4196:2;4191:3;4187:12;4180:19;;4011:194;;;;4213:113;4296:24;4314:5;4296:24;;;4291:3;4284:37;4278:48;;;4333:372;;4532:148;4676:3;4532:148;;;4525:155;;4697:3;4690:10;;4513:192;;;;4712:372;;4911:148;5055:3;4911:148;;;4904:155;;5076:3;5069:10;;4892:192;;;;5091:372;;5290:148;5434:3;5290:148;;;5283:155;;5455:3;5448:10;;5271:192;;;;5470:201;;5582:2;5571:9;5567:18;5559:26;;5596:65;5658:1;5647:9;5643:17;5634:6;5596:65;;;5553:118;;;;;5678:213;;5796:2;5785:9;5781:18;5773:26;;5810:71;5878:1;5867:9;5863:17;5854:6;5810:71;;;5767:124;;;;;5898:320;;6042:2;6031:9;6027:18;6019:26;;6056:71;6124:1;6113:9;6109:17;6100:6;6056:71;;;6138:70;6204:2;6193:9;6189:18;6180:6;6138:70;;;6013:205;;;;;;6225:209;;6341:2;6330:9;6326:18;6318:26;;6355:69;6421:1;6410:9;6406:17;6397:6;6355:69;;;6312:122;;;;;6441:235;;6570:2;6559:9;6555:18;6547:26;;6584:82;6663:1;6652:9;6648:17;6639:6;6584:82;;;6541:135;;;;;6683:424;;6855:2;6844:9;6840:18;6832:26;;6905:9;6899:4;6895:20;6891:1;6880:9;6876:17;6869:47;6930:84;7009:4;7000:6;6992;6930:84;;;6922:92;;7025:72;7093:2;7082:9;7078:18;7069:6;7025:72;;;6826:281;;;;;;;7114:213;;7232:2;7221:9;7217:18;7209:26;;7246:71;7314:1;7303:9;7299:17;7290:6;7246:71;;;7203:124;;;;;7335:163;;7450:6;7445:3;7438:19;7487:4;7482:3;7478:14;7463:29;;7431:67;;;;;7507:145;;7643:3;7628:18;;7621:31;;;;;7660:91;;7722:24;7740:5;7722:24;;;7711:35;;7705:46;;;;7758:85;;7831:5;7824:13;7817:21;7806:32;;7800:43;;;;7850:72;;7912:5;7901:16;;7895:27;;;;7929:144;;8001:66;7994:5;7990:78;7979:89;;7973:100;;;;8080:121;;8153:42;8146:5;8142:54;8131:65;;8125:76;;;;8208:72;;8270:5;8259:16;;8253:27;;;;8287:143;;8377:48;8419:5;8377:48;;;8364:61;;8358:72;;;;8437:119;;8527:24;8545:5;8527:24;;;8514:37;;8508:48;;;;8564:145;8645:6;8640:3;8635;8622:30;8701:1;8692:6;8687:3;8683:16;8676:27;8615:94;;;;8717:97;;8805:2;8801:7;8796:2;8789:5;8785:14;8781:28;8771:38;;8765:49;;;;8822:117;8891:24;8909:5;8891:24;;;8884:5;8881:35;8871:2;;8930:1;8927;8920:12;8871:2;8865:74;;8946:115;9014:23;9031:5;9014:23;;;9007:5;9004:34;8994:2;;9052:1;9049;9042:12;8994:2;8988:73;;9068:117;9137:24;9155:5;9137:24;;;9130:5;9127:35;9117:2;;9176:1;9173;9166:12;9117:2;9111:74;

bzzr://aef8589818b1d85a3f0681f26ae05e3a4114a56ce51fad2fd3e24172d9cc5f78