Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Context
•    - function _msgSender()
•    - function _msgData()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•  contract ERC20 is Context, IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _burnFrom(address account, u ...
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract COLToken is Ownable, ERC2 ...
•    - function beginLockDrop()
•  contract LockDrop *
•    - function lock()
•    - function claim(uint256 amount)
•    - function hasAmountToClaim(address cla ...
•    - function claimETH(address payable cla ...
•    - function claimTokensAndETH(address pa ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

pragma solidity 0.5.7;


contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        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-contracts/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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message 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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

     /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }
}

contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        _owner = _msgSender();
        emit OwnershipTransferred(address(0), _owner);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: 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 Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract COLToken is Ownable, ERC20 {
    using SafeMath for uint256;

    string public constant name    = "COL";
    string public constant symbol  = "COL";
    uint8 public constant decimals = 18;

    // Total supply cap - 200 billions;
    uint256 public constant teamSupply     =  40000000000; // 40 billions
    uint256 public constant lockDropSupply =  20000000000; // 20 billions
    uint256 public constant stakingSupply  = 140000000000; // 140 billions

    LockDrop public lockDropContract;
    address public teamMultisig;
    address public stakingMultisig;

    constructor(address teamMultisig_, address stakingMultisig_) public {
        teamMultisig = teamMultisig_;
        stakingMultisig = stakingMultisig_;

        _mint(teamMultisig, teamSupply * 10**uint256(decimals));
        _mint(stakingMultisig, stakingSupply * 10**uint256(decimals));
    }

    function beginLockDrop() external onlyOwner {
        require(address(lockDropContract) == address(0), "Can't do 2 lock drops");
        lockDropContract = new LockDrop(COLToken(this), lockDropSupply * 10**uint256(decimals));
        _mint(address(lockDropContract), lockDropSupply * 10**uint256(decimals));
    }
}

contract LockDrop {
    using SafeMath for uint256;

    uint256 public lockDeadline;
    uint256 public dropStartTimeStamp;
    uint256 totalAmountOfTokenDrop;
    uint256 totalLockedWei;

    COLToken lockingToken;

    struct LockerInfo {
        uint256 lockedAmount;
        uint256 lockTimestamp;
    }
    mapping (address => LockerInfo) public locks;

    event NewLock(address who, uint256 amount);
    event ClaimedETH(address who, uint256 amount);

    constructor(COLToken token, uint256 dropCap) public {
        lockingToken = token;
        totalAmountOfTokenDrop = dropCap;

        lockDeadline = now + 7 days;
        dropStartTimeStamp = lockDeadline + 7 days;
    }

    function lock() external payable {
        require(now < lockDeadline, "Locking action period is expired");
        require(msg.value > 0, "You should stake gt 0 amount of ETH");

        if (locks[msg.sender].lockTimestamp == 0) {
            locks[msg.sender].lockTimestamp = now;
        }
        locks[msg.sender].lockedAmount = locks[msg.sender].lockedAmount.add(msg.value);
        totalLockedWei = totalLockedWei.add(msg.value);

        emit NewLock(msg.sender, msg.value);
    }

    function claim(uint256 amount) external {
        require(hasAmountToClaim(msg.sender), "You don't have ETH or tokens to claim");

        if (now < dropStartTimeStamp) {
            claimETH(msg.sender, amount);
        } else {
            claimTokensAndETH(msg.sender);
        }
    }

    function hasAmountToClaim(address claimer) internal view returns (bool) {
        if (locks[claimer].lockedAmount == 0) {
            return false;
        }
        return true;
    }

    function claimETH(address payable claimer, uint256 amount) internal {
        require(amount > 0, "Claiming amount should be gt 0");

        // alias
        LockerInfo storage lI = locks[claimer];
        if (now >= lI.lockTimestamp + 7 days) {
            lI.lockedAmount = lI.lockedAmount.sub(amount, "Locked less then wanted to be claimed");
            totalLockedWei = totalLockedWei.sub(amount);

            claimer.transfer(amount);

            emit ClaimedETH(claimer, amount);
        } else {
            revert("Lock period hasn't expired yet");
        }
    }

    function claimTokensAndETH(address payable claimer) internal {
        // alias
        LockerInfo storage lI = locks[claimer];
        uint256 tokensForClaimer = totalAmountOfTokenDrop.mul(lI.lockedAmount).div(totalLockedWei);
        uint256 ETHForClaimer = lI.lockedAmount;
        lI.lockedAmount = 0;

        require(lockingToken.transfer(claimer, tokensForClaimer), "Token transfer failed");
        claimer.transfer(ETHForClaimer);

        emit ClaimedETH(claimer, ETHForClaimer);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"name":"amount","type":"uint256"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"locks","outputs":[{"name":"lockedAmount","type":"uint256"},{"name":"lockTimestamp","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"dropStartTimeStamp","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"lock","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"lockDeadline","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"token","type":"address"},{"name":"dropCap","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"who","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"NewLock","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"who","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"ClaimedETH","type":"event"}]

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

000000000000000000000000c76fb75950536d98fa62ea968e1d6b45ffea2a550000000000000000000000000000000000000000409f9cbc7c4a04c220000000

-----Decoded View---------------
Arg [0] : token (address): 0xC76FB75950536d98FA62ea968E1D6B45ffea2A55
Arg [1] : dropCap (uint256): 20000000000000000000000000000

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000c76fb75950536d98fa62ea968e1d6b45ffea2a55
Arg [1] : 0000000000000000000000000000000000000000409f9cbc7c4a04c220000000

18464:2834:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19689:296;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19689:296:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19689:296:0;;:::i;:::-;;18791:44;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18791:44:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18791:44:0;-1:-1:-1;;;;;18791:44:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;18558:33;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18558:33:0;;;:::i;:::-;;;;;;;;;;;;;;;;19182:499;;;:::i;18524:27::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18524:27:0;;;:::i;19689:296::-;19748:28;19765:10;19748:16;:28::i;:::-;19740:78;;;;-1:-1:-1;;;;;19740:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19841:18;;19835:3;:24;19831:147;;;19876:28;19885:10;19897:6;19876:8;:28::i;:::-;19831:147;;;19937:29;19955:10;19937:17;:29::i;:::-;19689:296;:::o;18791:44::-;;;;;;;;;;;;;;;;;;;:::o;18558:33::-;;;;:::o;19182:499::-;19240:12;;19234:3;:18;19226:63;;;;;-1:-1:-1;;;;;19226:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19320:1;19308:9;:13;19300:61;;;;-1:-1:-1;;;;;19300:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19384:10;19378:17;;;;:5;:17;;;;;:31;;;19374:106;;19437:10;19431:17;;;;:5;:17;;;;;19465:3;19431:31;;;;:37;19374:106;19529:10;19523:17;;;;:5;:17;;;;;:30;:45;;19558:9;19523:45;:34;:45;:::i;:::-;19496:10;19490:17;;;;:5;:17;;;;;:78;19596:14;;:29;;19615:9;19596:29;:18;:29;:::i;:::-;19579:14;:46;19643:30;;;19651:10;19643:30;;19663:9;19643:30;;;;;;;;;;;;;;;;;19182:499::o;18524:27::-;;;;:::o;19993:189::-;-1:-1:-1;;;;;20080:14:0;;20059:4;20080:14;;;:5;:14;;;;;:27;20076:77;;-1:-1:-1;20136:5:0;20129:12;;20076:77;-1:-1:-1;20170:4:0;19993:189;;;;:::o;20190:591::-;20286:1;20277:6;:10;20269:53;;;;;-1:-1:-1;;;;;20269:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20377:14:0;;20353:21;20377:14;;;:5;:14;;;;;-1:-1:-1;20413:16:0;;;20432:6;20413:25;20406:3;:32;20402:372;;20473:68;20493:6;20473:68;;;;;;;;;;;;;;;;;:15;;;:68;;:19;:68;:::i;:::-;20455:86;;20573:14;;:26;;20592:6;20573:26;:18;:26;:::i;:::-;20556:14;:43;20616:24;;-1:-1:-1;;;;;20616:16:0;;;:24;;;;;;;;;;;;:16;:24;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;20662:27:0;;;-1:-1:-1;;;;;20662:27:0;;;;;;;;;;;;;;;;;;;;;;;20402:372;;;20722:40;;;-1:-1:-1;;;;;20722:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;20402:372;20190:591;;;:::o;20789:506::-;-1:-1:-1;;;;;20903:14:0;;20879:21;20903:14;;;:5;:14;;;;;21003;;20982:15;;20955:22;;20903:14;;20879:21;20955:63;;21003:14;20955:43;;:22;:26;:43::i;:::-;:47;:63;:47;:63;:::i;:::-;21053:15;;21029:21;21079:19;;;21119:12;;;:48;;;-1:-1:-1;;;;;21119:48:0;;-1:-1:-1;;;;;21119:48:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21053:15:0;;21119:12;;;-1:-1:-1;;21119:48:0;;;;;;;;;;;;;;;;;;;:12;:48;;;5:2:-1;;;;30:1;27;20:12;5:2;21119:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;21119:48:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21119:48:0;21111:82;;;;;-1:-1:-1;;;;;21111:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21204:31;;-1:-1:-1;;;;;21204:16:0;;;:31;;;;;;;;;;;;:16;:31;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;21253:34:0;;;-1:-1:-1;;;;;21253:34:0;;;;;;;;;;;;;;;;;;;;;;;20789:506;;;;:::o;3600:181::-;3658:7;3690:5;;;3714:6;;;;3706:46;;;;;-1:-1:-1;;;;;3706:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;3772:1;-1:-1:-1;3600:181:0;;;;;:::o;4529:192::-;4615:7;4651:12;4643:6;;;;4635:29;;;;-1:-1:-1;;;;;4635:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;4635:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4687:5:0;;;4529:192::o;4056:136::-;4114:7;4141:43;4145:1;4148;4141:43;;;;;;;;;;;;;;;;;:3;:43::i;4972:471::-;5030:7;5275:6;5271:47;;-1:-1:-1;5305:1:0;5298:8;;5271:47;5342:5;;;5346:1;5342;:5;:1;5366:5;;;;;:10;5358:56;;;;-1:-1:-1;;;;;5358:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5911:132;5969:7;5996:39;6000:1;6003;5996:39;;;;;;;;;;;;;;;;;6659:7;6761:12;6754:5;6746:28;;;;-1:-1:-1;;;;;6746:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27:10;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;6746:28:0;;6785:9;6801:1;6797;:5;;;;;;;6573:345;-1:-1:-1;;;;;6573:345:0:o

bzzr://6fd5d8b3f26b5d01cc218c05a34d652fe7e0fdc90d8df73e55a11d3f433b1143