Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-08-14
*/

// File: SafeMath.sol

pragma solidity ^0.5.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

// File: ERC20.sol

pragma solidity ^0.5.10;

/// @title ERC20 interface is a subset of the ERC20 specification.
/// @notice see https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
    function allowance(address _owner, address _spender) external view returns (uint256);
    function approve(address _spender, uint256 _value) external returns (bool);
    function balanceOf(address _who) external view returns (uint256);
    function totalSupply() external view returns (uint256);
    function transfer(address _to, uint256 _value) external returns (bool);
    function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}

// File: Address.sol

pragma solidity ^0.5.0;

/**
 * @dev Collection of functions related to the address type,
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * > It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

// File: SafeERC20.sol

/**
 * The MIT License (MIT)
 *
 * Copyright (c) 2016-2019 zOS Global Limited
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

pragma solidity ^0.5.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(ERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(ERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(ERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(ERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(ERC20 token, bytes memory data) internal {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: ownable.sol

/**
 *  Ownable - The Consumer Contract Wallet
 *  Copyright (C) 2019 The Contract Wallet Company Limited
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.

 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.

 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

pragma solidity ^0.5.10;


/// @title Ownable has an owner address and provides basic authorization control functions.
/// This contract is modified version of the MIT OpenZepplin Ownable contract
/// This contract allows for the transferOwnership operation to be made impossible
/// https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/ownership/Ownable.sol
contract Ownable {
    event TransferredOwnership(address _from, address _to);
    event LockedOwnership(address _locked);

    address payable private _owner;
    bool private _isTransferable;

    /// @notice Constructor sets the original owner of the contract and whether or not it is one time transferable.
    constructor(address payable _account_, bool _transferable_) internal {
        _owner = _account_;
        _isTransferable = _transferable_;
        // Emit the LockedOwnership event if no longer transferable.
        if (!_isTransferable) {
            emit LockedOwnership(_account_);
        }
        emit TransferredOwnership(address(0), _account_);
    }

    /// @notice Reverts if called by any account other than the owner.
    modifier onlyOwner() {
        require(_isOwner(msg.sender), "sender is not an owner");
        _;
    }

    /// @notice Allows the current owner to transfer control of the contract to a new address.
    /// @param _account address to transfer ownership to.
    /// @param _transferable indicates whether to keep the ownership transferable.
    function transferOwnership(address payable _account, bool _transferable) external onlyOwner {
        // Require that the ownership is transferable.
        require(_isTransferable, "ownership is not transferable");
        // Require that the new owner is not the zero address.
        require(_account != address(0), "owner cannot be set to zero address");
        // Set the transferable flag to the value _transferable passed in.
        _isTransferable = _transferable;
        // Emit the LockedOwnership event if no longer transferable.
        if (!_transferable) {
            emit LockedOwnership(_account);
        }
        // Emit the ownership transfer event.
        emit TransferredOwnership(_owner, _account);
        // Set the owner to the provided address.
        _owner = _account;
    }

    /// @notice check if the ownership is transferable.
    /// @return true if the ownership is transferable.
    function isTransferable() external view returns (bool) {
        return _isTransferable;
    }

    /// @notice Allows the current owner to relinquish control of the contract.
    /// @dev Renouncing to ownership will leave the contract without an owner and unusable.
    /// @dev It will not be possible to call the functions with the `onlyOwner` modifier anymore.
    function renounceOwnership() external onlyOwner {
        // Require that the ownership is transferable.
        require(_isTransferable, "ownership is not transferable");
        // note that this could be terminal
        _owner = address(0);

        emit TransferredOwnership(_owner, address(0));
    }

    /// @notice Find out owner address
    /// @return address of the owner.
    function owner() public view returns (address payable) {
        return _owner;
    }

    /// @notice Check if owner address
    /// @return true if sender is the owner of the contract.
    function _isOwner(address _address) internal view returns (bool) {
        return _address == _owner;
    }
}

// File: transferrable.sol

/**
 *  Transferrable - The Consumer Contract Wallet
 *  Copyright (C) 2019 The Contract Wallet Company Limited
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.

 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.

 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

pragma solidity ^0.5.10;




/// @title SafeTransfer, allowing contract to withdraw tokens accidentally sent to itself
contract Transferrable {

    using SafeERC20 for ERC20;


    /// @dev This function is used to move tokens sent accidentally to this contract method.
    /// @dev The owner can chose the new destination address
    /// @param _to is the recipient's address.
    /// @param _asset is the address of an ERC20 token or 0x0 for ether.
    /// @param _amount is the amount to be transferred in base units.
    function _safeTransfer(address payable _to, address _asset, uint _amount) internal {
        // address(0) is used to denote ETH
        if (_asset == address(0)) {
            _to.transfer(_amount);
        } else {
            ERC20(_asset).safeTransfer(_to, _amount);
        }
    }
}

// File: controller.sol

/**
 *  Controller - The Consumer Contract Wallet
 *  Copyright (C) 2019 The Contract Wallet Company Limited
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.

 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.

 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

pragma solidity ^0.5.10;



/// @title The IController interface provides access to the isController and isAdmin checks.
interface IController {
    function isController(address) external view returns (bool);
    function isAdmin(address) external view returns (bool);
}


/// @title Controller stores a list of controller addresses that can be used for authentication in other contracts.
/// @notice The Controller implements a hierarchy of concepts, Owner, Admin, and the Controllers.
/// @dev Owner can change the Admins
/// @dev Admins and can the Controllers
/// @dev Controllers are used by the application.
contract Controller is IController, Ownable, Transferrable {

    event AddedController(address _sender, address _controller);
    event RemovedController(address _sender, address _controller);

    event AddedAdmin(address _sender, address _admin);
    event RemovedAdmin(address _sender, address _admin);

    event Claimed(address _to, address _asset, uint _amount);

    event Stopped(address _sender);
    event Started(address _sender);

    mapping (address => bool) private _isAdmin;
    uint private _adminCount;

    mapping (address => bool) private _isController;
    uint private _controllerCount;

    bool private _stopped;

    /// @notice Constructor initializes the owner with the provided address.
    /// @param _ownerAddress_ address of the owner.
    constructor(address payable _ownerAddress_) Ownable(_ownerAddress_, false) public {}

    /// @notice Checks if message sender is an admin.
    modifier onlyAdmin() {
        require(isAdmin(msg.sender), "sender is not an admin");
        _;
    }

    /// @notice Check if Owner or Admin
    modifier onlyAdminOrOwner() {
        require(_isOwner(msg.sender) || isAdmin(msg.sender), "sender is not an admin");
        _;
    }

    /// @notice Check if controller is stopped
    modifier notStopped() {
        require(!isStopped(), "controller is stopped");
        _;
    }

    /// @notice Add a new admin to the list of admins.
    /// @param _account address to add to the list of admins.
    function addAdmin(address _account) external onlyOwner notStopped {
        _addAdmin(_account);
    }

    /// @notice Remove a admin from the list of admins.
    /// @param _account address to remove from the list of admins.
    function removeAdmin(address _account) external onlyOwner {
        _removeAdmin(_account);
    }

    /// @return the current number of admins.
    function adminCount() external view returns (uint) {
        return _adminCount;
    }

    /// @notice Add a new controller to the list of controllers.
    /// @param _account address to add to the list of controllers.
    function addController(address _account) external onlyAdminOrOwner notStopped {
        _addController(_account);
    }

    /// @notice Remove a controller from the list of controllers.
    /// @param _account address to remove from the list of controllers.
    function removeController(address _account) external onlyAdminOrOwner {
        _removeController(_account);
    }

    /// @notice count the Controllers
    /// @return the current number of controllers.
    function controllerCount() external view returns (uint) {
        return _controllerCount;
    }

    /// @notice is an address an Admin?
    /// @return true if the provided account is an admin.
    function isAdmin(address _account) public view notStopped returns (bool) {
        return _isAdmin[_account];
    }

    /// @notice is an address a Controller?
    /// @return true if the provided account is a controller.
    function isController(address _account) public view notStopped returns (bool) {
        return _isController[_account];
    }

    /// @notice this function can be used to see if the controller has been stopped
    /// @return true is the Controller has been stopped
    function isStopped() public view returns (bool) {
        return _stopped;
    }

    /// @notice Internal-only function that adds a new admin.
    function _addAdmin(address _account) private {
        require(!_isAdmin[_account], "provided account is already an admin");
        require(!_isController[_account], "provided account is already a controller");
        require(!_isOwner(_account), "provided account is already the owner");
        require(_account != address(0), "provided account is the zero address");
        _isAdmin[_account] = true;
        _adminCount++;
        emit AddedAdmin(msg.sender, _account);
    }

    /// @notice Internal-only function that removes an existing admin.
    function _removeAdmin(address _account) private {
        require(_isAdmin[_account], "provided account is not an admin");
        _isAdmin[_account] = false;
        _adminCount--;
        emit RemovedAdmin(msg.sender, _account);
    }

    /// @notice Internal-only function that adds a new controller.
    function _addController(address _account) private {
        require(!_isAdmin[_account], "provided account is already an admin");
        require(!_isController[_account], "provided account is already a controller");
        require(!_isOwner(_account), "provided account is already the owner");
        require(_account != address(0), "provided account is the zero address");
        _isController[_account] = true;
        _controllerCount++;
        emit AddedController(msg.sender, _account);
    }

    /// @notice Internal-only function that removes an existing controller.
    function _removeController(address _account) private {
        require(_isController[_account], "provided account is not a controller");
        _isController[_account] = false;
        _controllerCount--;
        emit RemovedController(msg.sender, _account);
    }

    /// @notice stop our controllers and admins from being useable
    function stop() external onlyAdminOrOwner {
        _stopped = true;
        emit Stopped(msg.sender);
    }

    /// @notice start our controller again
    function start() external onlyOwner {
        _stopped = false;
        emit Started(msg.sender);
    }

    //// @notice Withdraw tokens from the smart contract to the specified account.
    function claim(address payable _to, address _asset, uint _amount) external onlyAdmin notStopped {
        _safeTransfer(_to, _asset, _amount);
        emit Claimed(_to, _asset, _amount);
    }
}

// File: ENS.sol

/**
 * BSD 2-Clause License
 *
 * Copyright (c) 2018, True Names Limited
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
pragma solidity ^0.5.0;

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);


    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external;
    function setResolver(bytes32 node, address resolver) external;
    function setOwner(bytes32 node, address owner) external;
    function setTTL(bytes32 node, uint64 ttl) 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);

}

// File: ResolverBase.sol

pragma solidity ^0.5.0;

contract ResolverBase {
    bytes4 private constant INTERFACE_META_ID = 0x01ffc9a7;

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == INTERFACE_META_ID;
    }

    function isAuthorised(bytes32 node) internal view returns(bool);

    modifier authorised(bytes32 node) {
        require(isAuthorised(node));
        _;
    }
}

// File: ABIResolver.sol

pragma solidity ^0.5.0;


contract ABIResolver is ResolverBase {
    bytes4 constant private ABI_INTERFACE_ID = 0x2203ab56;

    event ABIChanged(bytes32 indexed node, uint256 indexed contentType);

    mapping(bytes32=>mapping(uint256=>bytes)) abis;

    /**
     * Sets the ABI associated with an ENS node.
     * Nodes may have one ABI of each content type. To remove an ABI, set it to
     * the empty string.
     * @param node The node to update.
     * @param contentType The content type of the ABI
     * @param data The ABI data.
     */
    function setABI(bytes32 node, uint256 contentType, bytes calldata data) external authorised(node) {
        // Content types must be powers of 2
        require(((contentType - 1) & contentType) == 0);

        abis[node][contentType] = data;
        emit ABIChanged(node, contentType);
    }

    /**
     * Returns the ABI associated with an ENS node.
     * Defined in EIP205.
     * @param node The ENS node to query
     * @param contentTypes A bitwise OR of the ABI formats accepted by the caller.
     * @return contentType The content type of the return value
     * @return data The ABI data
     */
    function ABI(bytes32 node, uint256 contentTypes) external view returns (uint256, bytes memory) {
        mapping(uint256=>bytes) storage abiset = abis[node];

        for (uint256 contentType = 1; contentType <= contentTypes; contentType <<= 1) {
            if ((contentType & contentTypes) != 0 && abiset[contentType].length > 0) {
                return (contentType, abiset[contentType]);
            }
        }

        return (0, bytes(""));
    }

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == ABI_INTERFACE_ID || super.supportsInterface(interfaceID);
    }
}

// File: AddrResolver.sol

pragma solidity ^0.5.0;


contract AddrResolver is ResolverBase {
    bytes4 constant private ADDR_INTERFACE_ID = 0x3b3b57de;

    event AddrChanged(bytes32 indexed node, address a);

    mapping(bytes32=>address) addresses;

    /**
     * Sets the address associated with an ENS node.
     * May only be called by the owner of that node in the ENS registry.
     * @param node The node to update.
     * @param addr The address to set.
     */
    function setAddr(bytes32 node, address addr) external authorised(node) {
        addresses[node] = addr;
        emit AddrChanged(node, addr);
    }

    /**
     * Returns the address associated with an ENS node.
     * @param node The ENS node to query.
     * @return The associated address.
     */
    function addr(bytes32 node) public view returns (address) {
        return addresses[node];
    }

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == ADDR_INTERFACE_ID || super.supportsInterface(interfaceID);
    }
}

// File: ContentHashResolver.sol

pragma solidity ^0.5.0;


contract ContentHashResolver is ResolverBase {
    bytes4 constant private CONTENT_HASH_INTERFACE_ID = 0xbc1c58d1;

    event ContenthashChanged(bytes32 indexed node, bytes hash);

    mapping(bytes32=>bytes) hashes;

    /**
     * Sets the contenthash associated with an ENS node.
     * May only be called by the owner of that node in the ENS registry.
     * @param node The node to update.
     * @param hash The contenthash to set
     */
    function setContenthash(bytes32 node, bytes calldata hash) external authorised(node) {
        hashes[node] = hash;
        emit ContenthashChanged(node, hash);
    }

    /**
     * Returns the contenthash associated with an ENS node.
     * @param node The ENS node to query.
     * @return The associated contenthash.
     */
    function contenthash(bytes32 node) external view returns (bytes memory) {
        return hashes[node];
    }

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == CONTENT_HASH_INTERFACE_ID || super.supportsInterface(interfaceID);
    }
}

// File: InterfaceResolver.sol

pragma solidity ^0.5.0;



contract InterfaceResolver is ResolverBase, AddrResolver {
    bytes4 constant private INTERFACE_INTERFACE_ID = bytes4(keccak256("interfaceImplementer(bytes32,bytes4)"));
    bytes4 private constant INTERFACE_META_ID = 0x01ffc9a7;

    event InterfaceChanged(bytes32 indexed node, bytes4 indexed interfaceID, address implementer);

    mapping(bytes32=>mapping(bytes4=>address)) interfaces;

    /**
     * Sets an interface associated with a name.
     * Setting the address to 0 restores the default behaviour of querying the contract at `addr()` for interface support.
     * @param node The node to update.
     * @param interfaceID The EIP 168 interface ID.
     * @param implementer The address of a contract that implements this interface for this node.
     */
    function setInterface(bytes32 node, bytes4 interfaceID, address implementer) external authorised(node) {
        interfaces[node][interfaceID] = implementer;
        emit InterfaceChanged(node, interfaceID, implementer);
    }

    /**
     * Returns the address of a contract that implements the specified interface for this name.
     * If an implementer has not been set for this interfaceID and name, the resolver will query
     * the contract at `addr()`. If `addr()` is set, a contract exists at that address, and that
     * contract implements EIP168 and returns `true` for the specified interfaceID, its address
     * will be returned.
     * @param node The ENS node to query.
     * @param interfaceID The EIP 168 interface ID to check for.
     * @return The address that implements this interface, or 0 if the interface is unsupported.
     */
    function interfaceImplementer(bytes32 node, bytes4 interfaceID) external view returns (address) {
        address implementer = interfaces[node][interfaceID];
        if(implementer != address(0)) {
            return implementer;
        }

        address a = addr(node);
        if(a == address(0)) {
            return address(0);
        }

        (bool success, bytes memory returnData) = a.staticcall(abi.encodeWithSignature("supportsInterface(bytes4)", INTERFACE_META_ID));
        if(!success || returnData.length < 32 || returnData[31] == 0) {
            // EIP 168 not supported by target
            return address(0);
        }

        (success, returnData) = a.staticcall(abi.encodeWithSignature("supportsInterface(bytes4)", interfaceID));
        if(!success || returnData.length < 32 || returnData[31] == 0) {
            // Specified interface not supported by target
            return address(0);
        }

        return a;
    }

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == INTERFACE_INTERFACE_ID || super.supportsInterface(interfaceID);
    }
}

// File: NameResolver.sol

pragma solidity ^0.5.0;


contract NameResolver is ResolverBase {
    bytes4 constant private NAME_INTERFACE_ID = 0x691f3431;

    event NameChanged(bytes32 indexed node, string name);

    mapping(bytes32=>string) names;

    /**
     * Sets the name associated with an ENS node, for reverse records.
     * May only be called by the owner of that node in the ENS registry.
     * @param node The node to update.
     * @param name The name to set.
     */
    function setName(bytes32 node, string calldata name) external authorised(node) {
        names[node] = name;
        emit NameChanged(node, name);
    }

    /**
     * Returns the name associated with an ENS node, for reverse records.
     * Defined in EIP181.
     * @param node The ENS node to query.
     * @return The associated name.
     */
    function name(bytes32 node) external view returns (string memory) {
        return names[node];
    }

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == NAME_INTERFACE_ID || super.supportsInterface(interfaceID);
    }
}

// File: PubkeyResolver.sol

pragma solidity ^0.5.0;


contract PubkeyResolver is ResolverBase {
    bytes4 constant private PUBKEY_INTERFACE_ID = 0xc8690233;

    event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);

    struct PublicKey {
        bytes32 x;
        bytes32 y;
    }

    mapping(bytes32=>PublicKey) pubkeys;

    /**
     * Sets the SECP256k1 public key associated with an ENS node.
     * @param node The ENS node to query
     * @param x the X coordinate of the curve point for the public key.
     * @param y the Y coordinate of the curve point for the public key.
     */
    function setPubkey(bytes32 node, bytes32 x, bytes32 y) external authorised(node) {
        pubkeys[node] = PublicKey(x, y);
        emit PubkeyChanged(node, x, y);
    }

    /**
     * Returns the SECP256k1 public key associated with an ENS node.
     * Defined in EIP 619.
     * @param node The ENS node to query
     * @return x, y the X and Y coordinates of the curve point for the public key.
     */
    function pubkey(bytes32 node) external view returns (bytes32 x, bytes32 y) {
        return (pubkeys[node].x, pubkeys[node].y);
    }

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == PUBKEY_INTERFACE_ID || super.supportsInterface(interfaceID);
    }
}

// File: TextResolver.sol

pragma solidity ^0.5.0;


contract TextResolver is ResolverBase {
    bytes4 constant private TEXT_INTERFACE_ID = 0x59d1d43c;

    event TextChanged(bytes32 indexed node, string indexedKey, string key);

    mapping(bytes32=>mapping(string=>string)) texts;

    /**
     * Sets the text data associated with an ENS node and key.
     * May only be called by the owner of that node in the ENS registry.
     * @param node The node to update.
     * @param key The key to set.
     * @param value The text data value to set.
     */
    function setText(bytes32 node, string calldata key, string calldata value) external authorised(node) {
        texts[node][key] = value;
        emit TextChanged(node, key, key);
    }

    /**
     * Returns the text data associated with an ENS node and key.
     * @param node The ENS node to query.
     * @param key The text data key to query.
     * @return The associated text data.
     */
    function text(bytes32 node, string calldata key) external view returns (string memory) {
        return texts[node][key];
    }

    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
        return interfaceID == TEXT_INTERFACE_ID || super.supportsInterface(interfaceID);
    }
}

// File: PublicResolver.sol

/**
 * BSD 2-Clause License
 *
 * Copyright (c) 2018, True Names Limited
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

pragma solidity ^0.5.0;









/**
 * A simple resolver anyone can use; only allows the owner of a node to set its
 * address.
 */
contract PublicResolver is ABIResolver, AddrResolver, ContentHashResolver, InterfaceResolver, NameResolver, PubkeyResolver, TextResolver {
    ENS ens;

    /**
     * A mapping of authorisations. An address that is authorised for a name
     * may make any changes to the name that the owner could, but may not update
     * the set of authorisations.
     * (node, owner, caller) => isAuthorised
     */
    mapping(bytes32=>mapping(address=>mapping(address=>bool))) public authorisations;

    event AuthorisationChanged(bytes32 indexed node, address indexed owner, address indexed target, bool isAuthorised);

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

    /**
     * @dev Sets or clears an authorisation.
     * Authorisations are specific to the caller. Any account can set an authorisation
     * for any name, but the authorisation that is checked will be that of the
     * current owner of a name. Thus, transferring a name effectively clears any
     * existing authorisations, and new authorisations can be set in advance of
     * an ownership transfer if desired.
     *
     * @param node The name to change the authorisation on.
     * @param target The address that is to be authorised or deauthorised.
     * @param isAuthorised True if the address should be authorised, or false if it should be deauthorised.
     */
    function setAuthorisation(bytes32 node, address target, bool isAuthorised) external {
        authorisations[node][msg.sender][target] = isAuthorised;
        emit AuthorisationChanged(node, msg.sender, target, isAuthorised);
    }

    function isAuthorised(bytes32 node) internal view returns(bool) {
        address owner = ens.owner(node);
        return owner == msg.sender || authorisations[node][owner][msg.sender];
    }
}

// File: ensResolvable.sol

/**
 *  ENSResolvable - The Consumer Contract Wallet
 *  Copyright (C) 2019 The Contract Wallet Company Limited
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.

 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.

 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

pragma solidity ^0.5.10;




///@title ENSResolvable - Ethereum Name Service Resolver
///@notice contract should be used to get an address for an ENS node
contract ENSResolvable {
    /// @notice _ens is an instance of ENS
    ENS private _ens;

    /// @notice _ensRegistry points to the ENS registry smart contract.
    address private _ensRegistry;

    /// @param _ensReg_ is the ENS registry used
    constructor(address _ensReg_) internal {
        _ensRegistry = _ensReg_;
        _ens = ENS(_ensRegistry);
    }

    /// @notice this is used to that one can observe which ENS registry is being used
    function ensRegistry() external view returns (address) {
        return _ensRegistry;
    }

    /// @notice helper function used to get the address of a node
    /// @param _node of the ENS entry that needs resolving
    /// @return the address of the said node
    function _ensResolve(bytes32 _node) internal view returns (address) {
        return PublicResolver(_ens.resolver(_node)).addr(_node);
    }

}

// File: controllable.sol

/**
 *  Controllable - The Consumer Contract Wallet
 *  Copyright (C) 2019 The Contract Wallet Company Limited
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.

 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.

 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

pragma solidity ^0.5.10;




/// @title Controllable implements access control functionality of the Controller found via ENS.
contract Controllable is ENSResolvable {
    /// @dev Is the registered ENS node identifying the controller contract.
    bytes32 private _controllerNode;

    /// @notice Constructor initializes the controller contract object.
    /// @param _controllerNode_ is the ENS node of the Controller.
    constructor(bytes32 _controllerNode_) internal {
        _controllerNode = _controllerNode_;
    }

    /// @notice Checks if message sender is a controller.
    modifier onlyController() {
        require(_isController(msg.sender), "sender is not a controller");
        _;
    }

    /// @notice Checks if message sender is an admin.
    modifier onlyAdmin() {
        require(_isAdmin(msg.sender), "sender is not an admin");
        _;
    }

    /// @return the controller node registered in ENS.
    function controllerNode() external view returns (bytes32) {
        return _controllerNode;
    }

    /// @return true if the provided account is a controller.
    function _isController(address _account) internal view returns (bool) {
        return IController(_ensResolve(_controllerNode)).isController(_account);
    }

    /// @return true if the provided account is an admin.
    function _isAdmin(address _account) internal view returns (bool) {
        return IController(_ensResolve(_controllerNode)).isAdmin(_account);
    }

}

// File: licence.sol

/**
 *  Licence - The Consumer Contract Wallet
 *  Copyright (C) 2019 The Contract Wallet Company Limited
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.

 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.

 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

pragma solidity ^0.5.10;






/// @title ILicence interface describes methods for loading a TokenCard and updating licence amount.
interface ILicence {
    function load(address, uint) external payable;
    function updateLicenceAmount(uint) external;
}


/// @title Licence loads the TokenCard and transfers the licence amout to the TKN Holder Contract.
/// @notice the rest of the amount gets sent to the CryptoFloat
contract Licence is Transferrable, ENSResolvable, Controllable {

    using SafeMath for uint256;
    using SafeERC20 for ERC20;

    /*******************/
    /*     Events     */
    /*****************/

    event UpdatedLicenceDAO(address _newDAO);
    event UpdatedCryptoFloat(address _newFloat);
    event UpdatedTokenHolder(address _newHolder);
    event UpdatedTKNContractAddress(address _newTKN);
    event UpdatedLicenceAmount(uint _newAmount);

    event TransferredToTokenHolder(address _from, address _to, address _asset, uint _amount);
    event TransferredToCryptoFloat(address _from, address _to, address _asset, uint _amount);

    event Claimed(address _to, address _asset, uint _amount);

    /// @notice This is 100% scaled up by a factor of 10 to give us an extra 1 decimal place of precision
    uint constant public MAX_AMOUNT_SCALE = 1000;
    uint constant public MIN_AMOUNT_SCALE = 1;

    address private _tknContractAddress = 0xaAAf91D9b90dF800Df4F55c205fd6989c977E73a; // solium-disable-line uppercase

    address payable private _cryptoFloat;
    address payable private _tokenHolder;
    address private _licenceDAO;

    bool private _lockedCryptoFloat;
    bool private _lockedTokenHolder;
    bool private _lockedLicenceDAO;
    bool private _lockedTKNContractAddress;

    /// @notice This is the _licenceAmountScaled by a factor of 10
    /// @dev i.e. 1% is 10 _licenceAmountScaled, 0.1% is 1 _licenceAmountScaled
    uint private _licenceAmountScaled;

    /// @notice Reverts if called by any address other than the DAO contract.
    modifier onlyDAO() {
        require(msg.sender == _licenceDAO, "the sender isn't the DAO");
        _;
    }

    /// @notice Constructor initializes the card licence contract.
    /// @param _licence_ is the initial card licence amount. this number is scaled 10 = 1%, 9 = 0.9%
    /// @param _float_ is the address of the multi-sig cryptocurrency float contract.
    /// @param _holder_ is the address of the token holder contract
    /// @param _tknAddress_ is the address of the TKN ERC20 contract
    /// @param _ens_ is the address of the ENS Registry
    /// @param _controllerNode_ is the ENS node corresponding to the controller
    constructor(uint _licence_, address payable _float_, address payable _holder_, address _tknAddress_, address _ens_, bytes32 _controllerNode_) ENSResolvable(_ens_) Controllable(_controllerNode_) public {
        require(MIN_AMOUNT_SCALE <= _licence_ && _licence_ <= MAX_AMOUNT_SCALE, "licence amount out of range");
        _licenceAmountScaled = _licence_;
        _cryptoFloat = _float_;
        _tokenHolder = _holder_;
        if (_tknAddress_ != address(0)) {
            _tknContractAddress = _tknAddress_;
        }
    }

    /// @notice Ether can be deposited from any source, so this contract should be payable by anyone.
    function() external payable {}

    /// @notice this allows for people to see the scaled licence amount
    /// @return the scaled licence amount, used to calculate the split when loading.
    function licenceAmountScaled() external view returns (uint) {
        return _licenceAmountScaled;
    }

    /// @notice allows one to see the address of the CryptoFloat
    /// @return the address of the multi-sig cryptocurrency float contract.
    function cryptoFloat() external view returns (address) {
        return _cryptoFloat;
    }

    /// @notice allows one to see the address TKN holder contract
    /// @return the address of the token holder contract.
    function tokenHolder() external view returns (address) {
        return _tokenHolder;
    }

    /// @notice allows one to see the address of the DAO
    /// @return the address of the DAO contract.
    function licenceDAO() external view returns (address) {
        return _licenceDAO;
    }

    /// @notice The address of the TKN token
    /// @return the address of the TKN contract.
    function tknContractAddress() external view returns (address) {
        return _tknContractAddress;
    }

    /// @notice This locks the cryptoFloat address
    /// @dev so that it can no longer be updated
    function lockFloat() external onlyAdmin {
        _lockedCryptoFloat = true;
    }

    /// @notice This locks the TokenHolder address
    /// @dev so that it can no longer be updated
    function lockHolder() external onlyAdmin {
        _lockedTokenHolder = true;
    }

    /// @notice This locks the DAO address
    /// @dev so that it can no longer be updated
    function lockLicenceDAO() external onlyAdmin {
        _lockedLicenceDAO = true;
    }

    /// @notice This locks the TKN address
    /// @dev so that it can no longer be updated
    function lockTKNContractAddress() external onlyAdmin {
        _lockedTKNContractAddress = true;
    }

    /// @notice Updates the address of the cyptoFloat.
    /// @param _newFloat This is the new address for the CryptoFloat
    function updateFloat(address payable _newFloat) external onlyAdmin {
        require(!floatLocked(), "float is locked");
        _cryptoFloat = _newFloat;
        emit UpdatedCryptoFloat(_newFloat);
    }

    /// @notice Updates the address of the Holder contract.
    /// @param _newHolder This is the new address for the TokenHolder
    function updateHolder(address payable _newHolder) external onlyAdmin {
        require(!holderLocked(), "holder contract is locked");
        _tokenHolder = _newHolder;
        emit UpdatedTokenHolder(_newHolder);
    }

    /// @notice Updates the address of the DAO contract.
    /// @param _newDAO This is the new address for the Licence DAO
    function updateLicenceDAO(address _newDAO) external onlyAdmin {
        require(!licenceDAOLocked(), "DAO is locked");
        _licenceDAO = _newDAO;
        emit UpdatedLicenceDAO(_newDAO);
    }

    /// @notice Updates the address of the TKN contract.
    /// @param _newTKN This is the new address for the TKN contract
    function updateTKNContractAddress(address _newTKN) external onlyAdmin {
        require(!tknContractAddressLocked(), "TKN is locked");
        _tknContractAddress = _newTKN;
        emit UpdatedTKNContractAddress(_newTKN);
    }

    /// @notice Updates the TKN licence amount
    /// @param _newAmount is a number between MIN_AMOUNT_SCALE (1) and MAX_AMOUNT_SCALE
    function updateLicenceAmount(uint _newAmount) external onlyDAO {
        require(MIN_AMOUNT_SCALE <= _newAmount && _newAmount <= MAX_AMOUNT_SCALE, "licence amount out of range");
        _licenceAmountScaled = _newAmount;
        emit UpdatedLicenceAmount(_newAmount);
    }

    /// @notice Load the holder and float contracts based on the licence amount and asset amount.
    /// @param _asset is the address of an ERC20 token or 0x0 for ether.
    /// @param _amount is the amount of assets to be transferred including the licence amount.
    function load(address _asset, uint _amount) external payable {
        uint loadAmount = _amount;
        // If TKN then no licence to be paid
        if (_asset == _tknContractAddress) {
            ERC20(_asset).safeTransferFrom(msg.sender, _cryptoFloat, loadAmount);
        } else {
            loadAmount = _amount.mul(MAX_AMOUNT_SCALE).div(_licenceAmountScaled + MAX_AMOUNT_SCALE);
            uint licenceAmount = _amount.sub(loadAmount);

            if (_asset != address(0)) {
                ERC20(_asset).safeTransferFrom(msg.sender, _tokenHolder, licenceAmount);
                ERC20(_asset).safeTransferFrom(msg.sender, _cryptoFloat, loadAmount);
            } else {
                require(msg.value == _amount, "ETH sent is not equal to amount");
                _tokenHolder.transfer(licenceAmount);
                _cryptoFloat.transfer(loadAmount);
            }

            emit TransferredToTokenHolder(msg.sender, _tokenHolder, _asset, licenceAmount);
        }

        emit TransferredToCryptoFloat(msg.sender, _cryptoFloat, _asset, loadAmount);
    }

    //// @notice Withdraw tokens from the smart contract to the specified account.
    function claim(address payable _to, address _asset, uint _amount) external onlyAdmin {
        _safeTransfer(_to, _asset, _amount);
        emit Claimed(_to, _asset, _amount);
    }

    /// @notice returns whether or not the CryptoFloat address is locked
    function floatLocked() public view returns (bool) {
        return _lockedCryptoFloat;
    }

    /// @notice returns whether or not the TokenHolder address is locked
    function holderLocked() public view returns (bool) {
        return _lockedTokenHolder;
    }

    /// @notice returns whether or not the Licence DAO address is locked
    function licenceDAOLocked() public view returns (bool) {
        return _lockedLicenceDAO;
    }

    /// @notice returns whether or not the TKN address is locked
    function tknContractAddressLocked() public view returns (bool) {
        return _lockedTKNContractAddress;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[],"name":"lockTKNContractAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_newTKN","type":"address"}],"name":"updateTKNContractAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_asset","type":"address"},{"name":"_amount","type":"uint256"}],"name":"load","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"licenceDAO","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"MIN_AMOUNT_SCALE","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenHolder","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newHolder","type":"address"}],"name":"updateHolder","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"lockLicenceDAO","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_newAmount","type":"uint256"}],"name":"updateLicenceAmount","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"ensRegistry","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tknContractAddressLocked","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"floatLocked","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_asset","type":"address"},{"name":"_amount","type":"uint256"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"tknContractAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"cryptoFloat","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"licenceAmountScaled","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"MAX_AMOUNT_SCALE","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"lockFloat","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_newFloat","type":"address"}],"name":"updateFloat","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"lockHolder","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"controllerNode","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"licenceDAOLocked","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newDAO","type":"address"}],"name":"updateLicenceDAO","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"holderLocked","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_licence_","type":"uint256"},{"name":"_float_","type":"address"},{"name":"_holder_","type":"address"},{"name":"_tknAddress_","type":"address"},{"name":"_ens_","type":"address"},{"name":"_controllerNode_","type":"bytes32"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_newDAO","type":"address"}],"name":"UpdatedLicenceDAO","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_newFloat","type":"address"}],"name":"UpdatedCryptoFloat","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_newHolder","type":"address"}],"name":"UpdatedTokenHolder","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_newTKN","type":"address"}],"name":"UpdatedTKNContractAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_newAmount","type":"uint256"}],"name":"UpdatedLicenceAmount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_from","type":"address"},{"indexed":false,"name":"_to","type":"address"},{"indexed":false,"name":"_asset","type":"address"},{"indexed":false,"name":"_amount","type":"uint256"}],"name":"TransferredToTokenHolder","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_from","type":"address"},{"indexed":false,"name":"_to","type":"address"},{"indexed":false,"name":"_asset","type":"address"},{"indexed":false,"name":"_amount","type":"uint256"}],"name":"TransferredToCryptoFloat","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_to","type":"address"},{"indexed":false,"name":"_asset","type":"address"},{"indexed":false,"name":"_amount","type":"uint256"}],"name":"Claimed","type":"event"}]

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

000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000ab613544d53173e65e75a2390f7512f6fe94125700000000000000000000000024f0bb6c9b2c3db66603fa0ec07ab0cf55cdd387000000000000000000000000aaaf91d9b90df800df4f55c205fd6989c977e73a000000000000000000000000314159265dd8dbb310642f98f50c066173c1259b7f2ce995617d2816b426c5c8698c5ec2952f7a34bb10f38326f74933d5893697

-----Decoded View---------------
Arg [0] : _licence_ (uint256): 10
Arg [1] : _float_ (address): 0xab613544D53173E65e75a2390F7512F6fe941257
Arg [2] : _holder_ (address): 0x24F0bB6c9b2C3DB66603Fa0Ec07Ab0CF55cDd387
Arg [3] : _tknAddress_ (address): 0xaAAf91D9b90dF800Df4F55c205fd6989c977E73a
Arg [4] : _ens_ (address): 0x314159265dD8dbb310642f98f50C066173C1259b
Arg [5] : _controllerNode_ (bytes32): 0x7f2ce995617d2816b426c5c8698c5ec2952f7a34bb10f38326f74933d5893697

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [1] : 000000000000000000000000ab613544d53173e65e75a2390f7512f6fe941257
Arg [2] : 00000000000000000000000024f0bb6c9b2c3db66603fa0ec07ab0cf55cdd387
Arg [3] : 000000000000000000000000aaaf91d9b90df800df4f55c205fd6989c977e73a
Arg [4] : 000000000000000000000000314159265dd8dbb310642f98f50c066173c1259b
Arg [5] : 7f2ce995617d2816b426c5c8698c5ec2952f7a34bb10f38326f74933d5893697

46348:9096:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51134:104;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51134:104:0;;;:::i;52412:232::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52412:232:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52412:232:0;-1:-1:-1;;;;;52412:232:0;;:::i;53344:1100::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;53344:1100:0;;;;;;;;:::i;50151:91::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50151:91:0;;;:::i;:::-;;;;-1:-1:-1;;;;;50151:91:0;;;;;;;;;;;;;;47237:41;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47237:41:0;;;:::i;:::-;;;;;;;;;;;;;;;;49942:93;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49942:93:0;;;:::i;51720:223::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51720:223:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51720:223:0;-1:-1:-1;;;;;51720:223:0;;:::i;50944:88::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50944:88:0;;;:::i;52789:278::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52789:278:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52789:278:0;;:::i;42344:93::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42344:93:0;;;:::i;55327:114::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;55327:114:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;54802:94;;8:9:-1;5:2;;;30:1;27;20:12;5:2;54802:94:0;;;:::i;54536:184::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;54536:184:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;54536:184:0;;;;;;;;;;;;;;;;;:::i;50346:107::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50346:107:0;;;:::i;49715:93::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49715:93:0;;;:::i;49458:106::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49458:106:0;;;:::i;47186:44::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47186:44:0;;;:::i;50563:84::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50563:84:0;;;:::i;51372:208::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51372:208:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51372:208:0;-1:-1:-1;;;;;51372:208:0;;:::i;50757:85::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50757:85:0;;;:::i;44547:99::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44547:99:0;;;:::i;55155:98::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;55155:98:0;;;:::i;52077:200::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52077:200:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52077:200:0;-1:-1:-1;;;;;52077:200:0;;:::i;54978:95::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;54978:95:0;;;:::i;51134:104::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;51198:25;:32;;-1:-1:-1;;;;51198:32:0;-1:-1:-1;;;51198:32:0;;;51134:104::o;52412:232::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;52502:26;:24;:26::i;:::-;52501:27;52493:53;;;;;-1:-1:-1;;;52493:53:0;;;;;;;;;;;;-1:-1:-1;;;52493:53:0;;;;;;;;;;;;;;;52557:19;:29;;-1:-1:-1;;;;;52557:29:0;;-1:-1:-1;;;;;;52557:29:0;;;;;;;;52602:34;;;;;;;;;;;;;;;;52412:232;:::o;53344:1100::-;53512:19;;53434:7;;-1:-1:-1;;;;;53502:29:0;;;53512:19;;53502:29;53498:851;;;53591:12;;53548:68;;-1:-1:-1;;;;;53548:30:0;;;;53579:10;;53591:12;53605:10;53548:68;:30;:68;:::i;:::-;53498:851;;;53662:74;47226:4;53696:20;;:39;53662:29;47226:4;53662:7;:11;;:29;;;;:::i;:::-;:33;:74;:33;:74;:::i;:::-;53649:87;-1:-1:-1;53751:18:0;53772:23;:7;53649:87;53772:23;:11;:23;:::i;:::-;53751:44;-1:-1:-1;;;;;;53816:20:0;;;53812:431;;53900:12;;53857:71;;-1:-1:-1;;;;;53857:30:0;;;;53888:10;;53900:12;53914:13;53857:71;:30;:71;:::i;:::-;53990:12;;53947:68;;-1:-1:-1;;;;;53947:30:0;;;;53978:10;;53990:12;54004:10;53947:68;:30;:68;:::i;:::-;53812:431;;;54077:7;54064:9;:20;54056:64;;;;;-1:-1:-1;;;54056:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54139:12;;:36;;-1:-1:-1;;;;;54139:12:0;;;;:36;;;;;54161:13;;54139:12;:36;:12;:36;54161:13;54139:12;:36;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;54194:12:0;;:33;;-1:-1:-1;;;;;54194:12:0;;;;:33;;;;;54216:10;;54194:12;:33;:12;:33;54216:10;54194:12;:33;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54194:33:0;53812:431;54301:12;;54264:73;;;54289:10;54264:73;;-1:-1:-1;;;;;54301:12:0;;;54264:73;;;;;;;;;;;;;;;;;;;;;;;;;;;53498:851;;54403:12;;54366:70;;;54391:10;54366:70;;-1:-1:-1;;;;;54403:12:0;;;54366:70;;;;;;;;;;;;;;;;;;;;;;;;;;;53344:1100;;;:::o;50151:91::-;50223:11;;-1:-1:-1;;;;;50223:11:0;50151:91;:::o;47237:41::-;47277:1;47237:41;:::o;49942:93::-;50015:12;;-1:-1:-1;;;;;50015:12:0;49942:93;:::o;51720:223::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;51809:14;:12;:14::i;:::-;51808:15;51800:53;;;;;-1:-1:-1;;;51800:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;51864:12;:25;;-1:-1:-1;;;;;51864:25:0;;-1:-1:-1;;;;;;51864:25:0;;;;;;;;51905:30;;;;;;;;;;;;;;;;51720:223;:::o;50944:88::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;51000:17;:24;;-1:-1:-1;;;;51000:24:0;-1:-1:-1;;;51000:24:0;;;50944:88::o;52789:278::-;48013:11;;-1:-1:-1;;;;;48013:11:0;47999:10;:25;47991:62;;;;;-1:-1:-1;;;47991:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;52891:10;47277:1;52871:30;;:64;;;;;47226:4;52905:10;:30;;52871:64;52863:104;;;;;-1:-1:-1;;;52863:104:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;52978:20;:33;;;53027:32;;;;;;;;;;;;;;;;;52789:278;:::o;42344:93::-;42417:12;;-1:-1:-1;;;;;42417:12:0;42344:93;:::o;55327:114::-;55408:25;;-1:-1:-1;;;55408:25:0;;;;;55327:114::o;54802:94::-;54870:18;;-1:-1:-1;;;54870:18:0;;;;;54802:94::o;54536:184::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;54632:35;54646:3;54651:6;54659:7;54632:13;:35::i;:::-;54683:29;;;-1:-1:-1;;;;;54683:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54536:184;;;:::o;50346:107::-;50426:19;;-1:-1:-1;;;;;50426:19:0;50346:107;:::o;49715:93::-;49788:12;;-1:-1:-1;;;;;49788:12:0;49715:93;:::o;49458:106::-;49536:20;;49458:106;:::o;47186:44::-;47226:4;47186:44;:::o;50563:84::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;50614:18;:25;;-1:-1:-1;;;;50614:25:0;-1:-1:-1;;;50614:25:0;;;50563:84::o;51372:208::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;51459:13;:11;:13::i;:::-;51458:14;51450:42;;;;;-1:-1:-1;;;51450:42:0;;;;;;;;;;;;-1:-1:-1;;;51450:42:0;;;;;;;;;;;;;;;51503:12;:24;;-1:-1:-1;;;;;51503:24:0;;-1:-1:-1;;;;;;51503:24:0;;;;;;;;51543:29;;;;;;;;;;;;;;;;51372:208;:::o;50757:85::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;50809:18;:25;;-1:-1:-1;;;;50809:25:0;-1:-1:-1;;;50809:25:0;;;50757:85::o;44547:99::-;44623:15;;44547:99;:::o;55155:98::-;55228:17;;-1:-1:-1;;;55228:17:0;;;;;55155:98::o;52077:200::-;44416:20;44425:10;44416:8;:20::i;:::-;44408:55;;;;;-1:-1:-1;;;44408:55:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;44408:55:0;;;;;;;;;;;;;;;52159:18;:16;:18::i;:::-;52158:19;52150:45;;;;;-1:-1:-1;;;52150:45:0;;;;;;;;;;;;-1:-1:-1;;;52150:45:0;;;;;;;;;;;;;;;52206:11;:21;;-1:-1:-1;;;;;52206:21:0;;-1:-1:-1;;;;;;52206:21:0;;;;;;;;52243:26;;;;;;;;;;;;;;;;52077:200;:::o;54978:95::-;55047:18;;-1:-1:-1;;;55047:18:0;;;;;54978:95::o;44944:150::-;45003:4;45039:28;45051:15;;45039:11;:28::i;:::-;-1:-1:-1;;;;;45027:49:0;;45077:8;45027:59;;;;;;;;;;;;;-1:-1:-1;;;;;45027:59:0;-1:-1:-1;;;;;45027:59:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45027:59:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45027:59:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45027:59:0;;44944:150;-1:-1:-1;;44944:150:0:o;7338:203::-;7464:68;;;-1:-1:-1;;;;;7464:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;7464:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;7438:95:0;;7457:5;;7438:18;:95::i;:::-;7338:203;;;;:::o;1775:470::-;1833:7;2077:6;2073:47;;-1:-1:-1;2107:1:0;2100:8;;2073:47;2144:5;;;2148:1;2144;:5;:1;2168:5;;;;;:10;2160:56;;;;-1:-1:-1;;;2160:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2236:1;-1:-1:-1;1775:470:0;;;;;:::o;2713:333::-;2771:7;2870:1;2866;:5;2858:44;;;;;-1:-1:-1;;;2858:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;2913:9;2929:1;2925;:5;;;;;;;2713:333;-1:-1:-1;;;;2713:333:0:o;1340:184::-;1398:7;1431:1;1426;:6;;1418:49;;;;;-1:-1:-1;;;1418:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1490:5:0;;;1340:184::o;15986:293::-;-1:-1:-1;;;;;16129:20:0;;16125:147;;16166:21;;-1:-1:-1;;;;;16166:12:0;;;:21;;;;;16179:7;;16166:21;;;;16179:7;16166:12;:21;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;16166:21:0;16125:147;;;16220:40;-1:-1:-1;;;;;16220:26:0;;16247:3;16252:7;16220:40;:26;:40;:::i;:::-;15986:293;;;:::o;42618:142::-;42677:7;42719:4;;:20;;;-1:-1:-1;;;42719:20:0;;;;;;;;;;-1:-1:-1;;;;;42719:4:0;;;;:13;;:20;;;;;;;;;;;;;;;:4;:20;;;5:2:-1;;;;30:1;27;20:12;5:2;42719:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;42719:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42719:20:0;42704:48;;;-1:-1:-1;;;42704:48:0;;;;;;;;;;-1:-1:-1;;;;;42704:41:0;;;;;;:48;;;;;42719:20;;42704:48;;;;;;;;:41;:48;;;5:2:-1;;;;30:1;27;20:12;9144:1114:0;9748:27;9756:5;-1:-1:-1;;;;;9748:25:0;;:27::i;:::-;9740:71;;;;;-1:-1:-1;;;9740:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9885:12;9899:23;9934:5;-1:-1:-1;;;;;9926:19:0;9946:4;9926:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;9926:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;9884:67:0;;;;9970:7;9962:52;;;;;-1:-1:-1;;;9962:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10031:17;;:21;10027:224;;10173:10;10162:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;10162:30:0;10154:85;;;;-1:-1:-1;;;10154:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7155:175;7263:58;;;-1:-1:-1;;;;;7263:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;7263:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;7237:85:0;;7256:5;;7237:18;:85::i;4923:422::-;5290:20;5329:8;;;4923:422::o

bzzr://fcb2619e3b6b1d323cf6d8f408ae9fef5fc6965792a11e4b00d62d50183b4d2e