Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-05-31
*/

// File: contracts/common/governance/IGovernance.sol

pragma solidity ^0.5.2;


interface IGovernance {
    function update(address target, bytes calldata data) external;
}

// File: contracts/common/governance/Governable.sol

pragma solidity ^0.5.2;


contract Governable {
    IGovernance public governance;

    constructor(address _governance) public {
        governance = IGovernance(_governance);
    }

    modifier onlyGovernance() {
        require(msg.sender == address(governance), "Only governance contract is authorized");
        _;
    }
}

// File: contracts/root/withdrawManager/IWithdrawManager.sol

pragma solidity ^0.5.2;


contract IWithdrawManager {
    function createExitQueue(address token) external;

    function verifyInclusion(
        bytes calldata data,
        uint8 offset,
        bool verifyTxInclusion
    ) external view returns (uint256 age);

    function addExitToQueue(
        address exitor,
        address childToken,
        address rootToken,
        uint256 exitAmountOrTokenId,
        bytes32 txHash,
        bool isRegularExit,
        uint256 priority
    ) external;

    function addInput(
        uint256 exitId,
        uint256 age,
        address utxoOwner,
        address token
    ) external;

    function challengeExit(
        uint256 exitId,
        uint256 inputId,
        bytes calldata challengeData,
        address adjudicatorPredicate
    ) external;
}

// File: contracts/common/Registry.sol

pragma solidity ^0.5.2;


contract Registry is Governable {
    // @todo hardcode constants
    bytes32 private constant WETH_TOKEN = keccak256("wethToken");
    bytes32 private constant DEPOSIT_MANAGER = keccak256("depositManager");
    bytes32 private constant STAKE_MANAGER = keccak256("stakeManager");
    bytes32 private constant VALIDATOR_SHARE = keccak256("validatorShare");
    bytes32 private constant WITHDRAW_MANAGER = keccak256("withdrawManager");
    bytes32 private constant CHILD_CHAIN = keccak256("childChain");
    bytes32 private constant STATE_SENDER = keccak256("stateSender");
    bytes32 private constant SLASHING_MANAGER = keccak256("slashingManager");

    address public erc20Predicate;
    address public erc721Predicate;

    mapping(bytes32 => address) public contractMap;
    mapping(address => address) public rootToChildToken;
    mapping(address => address) public childToRootToken;
    mapping(address => bool) public proofValidatorContracts;
    mapping(address => bool) public isERC721;

    enum Type {Invalid, ERC20, ERC721, Custom}
    struct Predicate {
        Type _type;
    }
    mapping(address => Predicate) public predicates;

    event TokenMapped(address indexed rootToken, address indexed childToken);
    event ProofValidatorAdded(address indexed validator, address indexed from);
    event ProofValidatorRemoved(address indexed validator, address indexed from);
    event PredicateAdded(address indexed predicate, address indexed from);
    event PredicateRemoved(address indexed predicate, address indexed from);
    event ContractMapUpdated(bytes32 indexed key, address indexed previousContract, address indexed newContract);

    constructor(address _governance) public Governable(_governance) {}

    function updateContractMap(bytes32 _key, address _address) external onlyGovernance {
        emit ContractMapUpdated(_key, contractMap[_key], _address);
        contractMap[_key] = _address;
    }

    /**
     * @dev Map root token to child token
     * @param _rootToken Token address on the root chain
     * @param _childToken Token address on the child chain
     * @param _isERC721 Is the token being mapped ERC721
     */
    function mapToken(
        address _rootToken,
        address _childToken,
        bool _isERC721
    ) external onlyGovernance {
        require(_rootToken != address(0x0) && _childToken != address(0x0), "INVALID_TOKEN_ADDRESS");
        rootToChildToken[_rootToken] = _childToken;
        childToRootToken[_childToken] = _rootToken;
        isERC721[_rootToken] = _isERC721;
        IWithdrawManager(contractMap[WITHDRAW_MANAGER]).createExitQueue(_rootToken);
        emit TokenMapped(_rootToken, _childToken);
    }

    function addErc20Predicate(address predicate) public onlyGovernance {
        require(predicate != address(0x0), "Can not add null address as predicate");
        erc20Predicate = predicate;
        addPredicate(predicate, Type.ERC20);
    }

    function addErc721Predicate(address predicate) public onlyGovernance {
        erc721Predicate = predicate;
        addPredicate(predicate, Type.ERC721);
    }

    function addPredicate(address predicate, Type _type) public onlyGovernance {
        require(predicates[predicate]._type == Type.Invalid, "Predicate already added");
        predicates[predicate]._type = _type;
        emit PredicateAdded(predicate, msg.sender);
    }

    function removePredicate(address predicate) public onlyGovernance {
        require(predicates[predicate]._type != Type.Invalid, "Predicate does not exist");
        delete predicates[predicate];
        emit PredicateRemoved(predicate, msg.sender);
    }

    function getValidatorShareAddress() public view returns (address) {
        return contractMap[VALIDATOR_SHARE];
    }

    function getWethTokenAddress() public view returns (address) {
        return contractMap[WETH_TOKEN];
    }

    function getDepositManagerAddress() public view returns (address) {
        return contractMap[DEPOSIT_MANAGER];
    }

    function getStakeManagerAddress() public view returns (address) {
        return contractMap[STAKE_MANAGER];
    }

    function getSlashingManagerAddress() public view returns (address) {
        return contractMap[SLASHING_MANAGER];
    }

    function getWithdrawManagerAddress() public view returns (address) {
        return contractMap[WITHDRAW_MANAGER];
    }

    function getChildChainAndStateSender() public view returns (address, address) {
        return (contractMap[CHILD_CHAIN], contractMap[STATE_SENDER]);
    }

    function isTokenMapped(address _token) public view returns (bool) {
        return rootToChildToken[_token] != address(0x0);
    }

    function isTokenMappedAndIsErc721(address _token) public view returns (bool) {
        require(isTokenMapped(_token), "TOKEN_NOT_MAPPED");
        return isERC721[_token];
    }

    function isTokenMappedAndGetPredicate(address _token) public view returns (address) {
        if (isTokenMappedAndIsErc721(_token)) {
            return erc721Predicate;
        }
        return erc20Predicate;
    }

    function isChildTokenErc721(address childToken) public view returns (bool) {
        address rootToken = childToRootToken[childToken];
        require(rootToken != address(0x0), "Child token is not mapped");
        return isERC721[rootToken];
    }
}

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

pragma solidity ^0.5.2;


/**
 * @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.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     * @notice Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    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/common/misc/ProxyStorage.sol

pragma solidity ^0.5.2;


contract ProxyStorage is Ownable {
    address internal proxyTo;
}

// File: contracts/common/mixin/ChainIdMixin.sol

pragma solidity ^0.5.2;


contract ChainIdMixin {
    bytes public constant networkId = hex"89";
    uint256 public constant CHAINID = 137;
}

// File: contracts/root/RootChainStorage.sol

pragma solidity ^0.5.2;


contract RootChainHeader {
    event NewHeaderBlock(
        address indexed proposer,
        uint256 indexed headerBlockId,
        uint256 indexed reward,
        uint256 start,
        uint256 end,
        bytes32 root
    );
    // housekeeping event
    event ResetHeaderBlock(address indexed proposer, uint256 indexed headerBlockId);
    struct HeaderBlock {
        bytes32 root;
        uint256 start;
        uint256 end;
        uint256 createdAt;
        address proposer;
    }
}


contract RootChainStorage is ProxyStorage, RootChainHeader, ChainIdMixin {
    bytes32 public heimdallId;
    uint8 public constant VOTE_TYPE = 2;

    uint16 internal constant MAX_DEPOSITS = 10000;
    uint256 public _nextHeaderBlock = MAX_DEPOSITS;
    uint256 internal _blockDepositId = 1;
    mapping(uint256 => HeaderBlock) public headerBlocks;
    Registry internal registry;
}

// File: contracts/common/misc/ERCProxy.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.5.2;


// See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-897.md

interface ERCProxy {
    function proxyType() external pure returns (uint256 proxyTypeId);

    function implementation() external view returns (address codeAddr);
}

// File: contracts/common/misc/DelegateProxy.sol

pragma solidity ^0.5.2;


contract DelegateProxy is ERCProxy {
    function proxyType() external pure returns (uint256 proxyTypeId) {
        // Upgradeable proxy
        proxyTypeId = 2;
    }

    function implementation() external view returns (address);

    function delegatedFwd(address _dst, bytes memory _calldata) internal {
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let result := delegatecall(sub(gas, 10000), _dst, add(_calldata, 0x20), mload(_calldata), 0, 0)
            let size := returndatasize

            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)

            // revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
            // if the call returned error data, forward it
            switch result
                case 0 {
                    revert(ptr, size)
                }
                default {
                    return(ptr, size)
                }
        }
    }
}

// File: contracts/common/misc/Proxy.sol

pragma solidity ^0.5.2;


contract Proxy is ProxyStorage, DelegateProxy {
    event ProxyUpdated(address indexed _new, address indexed _old);
    event OwnerUpdate(address _prevOwner, address _newOwner);

    constructor(address _proxyTo) public {
        updateImplementation(_proxyTo);
    }

    function() external payable {
        // require(currentContract != 0, "If app code has not been set yet, do not call");
        // Todo: filter out some calls or handle in the end fallback
        delegatedFwd(proxyTo, msg.data);
    }

    function implementation() external view returns (address) {
        return proxyTo;
    }

    function updateImplementation(address _newProxyTo) public onlyOwner {
        require(_newProxyTo != address(0x0), "INVALID_PROXY_ADDRESS");
        require(isContract(_newProxyTo), "DESTINATION_ADDRESS_IS_NOT_A_CONTRACT");
        emit ProxyUpdated(_newProxyTo, proxyTo);
        proxyTo = _newProxyTo;
    }

    function isContract(address _target) internal view returns (bool) {
        if (_target == address(0)) {
            return false;
        }

        uint256 size;
        assembly {
            size := extcodesize(_target)
        }
        return size > 0;
    }
}

// File: contracts/root/RootChainProxy.sol

pragma solidity ^0.5.2;


contract RootChainProxy is Proxy, RootChainStorage {
    constructor(
        address _proxyTo,
        address _registry,
        string memory _heimdallId
    ) public Proxy(_proxyTo) {
        registry = Registry(_registry);
        heimdallId = keccak256(abi.encodePacked(_heimdallId));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"internalType":"address","name":"_newProxyTo","type":"address"}],"name":"updateImplementation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"headerBlocks","outputs":[{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"uint256","name":"createdAt","type":"uint256"},{"internalType":"address","name":"proposer","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"proxyType","outputs":[{"internalType":"uint256","name":"proxyTypeId","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_nextHeaderBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"networkId","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"CHAINID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"VOTE_TYPE","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"heimdallId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_proxyTo","type":"address"},{"internalType":"address","name":"_registry","type":"address"},{"internalType":"string","name":"_heimdallId","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proposer","type":"address"},{"indexed":true,"internalType":"uint256","name":"headerBlockId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"reward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"start","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"end","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"NewHeaderBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proposer","type":"address"},{"indexed":true,"internalType":"uint256","name":"headerBlockId","type":"uint256"}],"name":"ResetHeaderBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_new","type":"address"},{"indexed":true,"internalType":"address","name":"_old","type":"address"}],"name":"ProxyUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_prevOwner","type":"address"},{"indexed":false,"internalType":"address","name":"_newOwner","type":"address"}],"name":"OwnerUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

0000000000000000000000005a09cd4601b66bc107d377ab81e0dbb5dfabaa8400000000000000000000000033a02e6cc863d393d6bf231b697b82f6e499ca710000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000c6865696d64616c6c2d3133370000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _proxyTo (address): 0x5A09cD4601b66bc107D377AB81E0dbb5dFABaA84
Arg [1] : _registry (address): 0x33a02E6cC863D393d6Bf231B697b82F6e499cA71
Arg [2] : _heimdallId (string): heimdall-137

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000005a09cd4601b66bc107d377ab81e0dbb5dfabaa84
Arg [1] : 00000000000000000000000033a02e6cc863d393d6bf231b697b82f6e499ca71
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [4] : 6865696d64616c6c2d3133370000000000000000000000000000000000000000

13531:307:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12720:7;;12707:31;;;;12729:8;12707:31;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12720:7:0;;-1:-1:-1;;12729:8:0;;12707:31;;-1:-1:-1;12729:8:0;;-1:-1:-1;12707:31:0;1:33:-1;99:1;81:16;;74:27;;;;-1:-1;12707:12:0;;-1:-1:-1;;;12707:31:0:i;:::-;13531:307;12853:314;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12853:314:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;12853:314:0;-1:-1:-1;;;;;12853:314:0;;:::i;10584:51::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;10584:51:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;10584:51:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;10584:51:0;;;;;;;;;;;;;;11167:129;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11167:129:0;;;:::i;:::-;;;;;;;;;;;;;;;;12754:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12754:91:0;;;:::i;:::-;;;;-1:-1:-1;;;;;12754:91:0;;;;;;;;;;;;;;8562:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8562:140:0;;;:::i;10488:46::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;10488:46:0;;;:::i;7772:79::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7772:79:0;;;:::i;8107:92::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8107:92:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;9594:41;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9594:41:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;9594:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9642:37;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9642:37:0;;;:::i;10392:35::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;10392:35:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;8879:109;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8879:109:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;8879:109:0;-1:-1:-1;;;;;8879:109:0;;:::i;10360:25::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;10360:25:0;;;:::i;11370:775::-;11632:1;11629;11617:9;11611:16;11604:4;11593:9;11589:20;11583:4;11575:5;11570:3;11566:15;11553:81;11660:14;11707:4;11701:11;11749:4;11746:1;11741:3;11726:28;11952:6;11976:66;;;;12103:4;12098:3;12091:17;11976:66;12018:4;12013:3;12006:17;12853:314;7984:9;:7;:9::i;:::-;7976:18;;;;;;-1:-1:-1;;;;;12940:27:0;;12932:61;;;;;-1:-1:-1;;;12932:61:0;;;;;;;;;;;;-1:-1:-1;;;12932:61:0;;;;;;;;;;;;;;;13012:23;13023:11;13012:10;:23::i;:::-;13004:73;;;;-1:-1:-1;;;13004:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13119:7;;13093:34;;-1:-1:-1;;;;;13119:7:0;;;;13093:34;;;;;13119:7;;13093:34;13138:7;:21;;-1:-1:-1;;;;;;13138:21:0;-1:-1:-1;;;;;13138:21:0;;;;;;;;;;12853:314::o;10584:51::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;10584:51:0;;:::o;11167:129::-;11287:1;;11167:129::o;12754:91::-;12830:7;;-1:-1:-1;;;;;12830:7:0;12754:91;:::o;8562:140::-;7984:9;:7;:9::i;:::-;7976:18;;;;;;8661:1;8645:6;;8624:40;;-1:-1:-1;;;;;8645:6:0;;;;8624:40;;8661:1;;8624:40;8692:1;8675:19;;-1:-1:-1;;;;;;8675:19:0;;;8562:140::o;10488:46::-;;;;:::o;7772:79::-;7810:7;7837:6;-1:-1:-1;;;;;7837:6:0;7772:79;:::o;8107:92::-;8147:4;8185:6;-1:-1:-1;;;;;8185:6:0;8171:10;:20;;8107:92::o;9594:41::-;;;;;;;;;;;;;;-1:-1:-1;;;9594:41:0;;;;:::o;9642:37::-;9676:3;9642:37;:::o;10392:35::-;10426:1;10392:35;:::o;8879:109::-;7984:9;:7;:9::i;:::-;7976:18;;;;;;8952:28;8971:8;8952:18;:28::i;:::-;8879:109;:::o;10360:25::-;;;;:::o;13175:274::-;13235:4;-1:-1:-1;;;;;13256:21:0;;13252:66;;-1:-1:-1;13301:5:0;13294:12;;13252:66;-1:-1:-1;13385:20:0;;13433:8;;13175:274;;;;:::o;9138:187::-;-1:-1:-1;;;;;9212:22:0;;9204:31;;;;;;9272:6;;;9251:38;;-1:-1:-1;;;;;9251:38:0;;;;9272:6;;;9251:38;;;9300:6;:17;;-1:-1:-1;;;;;;9300:17:0;-1:-1:-1;;;;;9300:17:0;;;;;;;;;;9138:187::o

bzzr://e752e7f14517f3a29e68bac194e90e96833fd72744ab6a77b241ad75ce528cda