Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

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 Timelock    - function init(address _admin, uint _d ...    - function()    - function setDelay(uint delay_)    - function acceptAdmin()    - function setPendingAdmin(address pend ...    - function queueTransaction(address tar ...    - function cancelTransaction(address ta ...    - function executeTransaction(address t ...    - function getBlockTimestamp()  contract GovernanceToken *    - function allowance(address account, a ...    - function approve(address spender, uin ...    - function balanceOf(address account)    - function transfer(address dst, uint r ...    - function transferFrom(address src, ad ...    - function delegate(address delegatee)    - function delegateBySig(address delega ...    - function getCurrentVotes(address acco ...    - function getPriorVotes(address accoun ...    - function _delegate(address delegator, ...    - function _transferTokens(address src, ...    - function _moveDelegates(address srcRe ...    - function _writeCheckpoint(address del ...    - function safe32(uint n, string memory ...    - function safe96(uint n, string memory ...    - function add96(uint96 a, uint96 b, st ...    - function sub96(uint96 a, uint96 b, st ...    - function getChainId()  contract GovernorAlpha    - function proposalMaxOperations()    - function votingDelay()    - function init(address _timelock, addr ...    - function propose(address[] memory tar ...    - function queue(uint proposalId)    - function _queueOrRevert(address targe ...    - function execute(uint proposalId)    - function cancel(uint proposalId)    - function getActions(uint proposalId)    - function getReceipt(uint proposalId, ...    - function state(uint proposalId)    - function castVote(uint proposalId, bo ...    - function castVoteBySig(uint proposalI ...    - function _castVote(address voter, uin ...    - function __acceptAdmin()    - function __abdicate()    - function __queueSetTimelockPendingAdm ...    - function __executeSetTimelockPendingA ...    - function add256(uint256 a, uint256 b)    - function sub256(uint256 a, uint256 b)    - function getChainId() interface TimelockInterface    - function delay()    - function GRACE_PERIOD()    - function acceptAdmin()    - function queuedTransactions(bytes32 h ...    - function queueTransaction(address tar ...    - function cancelTransaction(address ta ...    - function executeTransaction(address t ... interface CompInterface    - function getPriorVotes(address accoun ...  contract CloneFactory    - function createClone(address target)    - function isClone(address target, addr ...  contract GovernanceFactory is Clon ...    - function deployGovernance(address adm ...    - function initTimeLock(address admin, ...    - function initGovernor(address timeloc ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-06-15
*/

pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;

// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.

/**
 * @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) {
        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.
     *
     * NOTE: This is a feature of the next version of OpenZeppelin Contracts.
     * @dev Get it via `npm install @openzeppelin/contracts@next`.
     */
    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.
     * NOTE: This is a feature of the next version of OpenZeppelin Contracts.
     * @dev Get it via `npm install @openzeppelin/contracts@next`.
     */
    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.
     *
     * NOTE: This is a feature of the next version of OpenZeppelin Contracts.
     * @dev Get it via `npm install @openzeppelin/contracts@next`.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

/// @notice Based on Compound Governance.
contract Timelock {
    using SafeMath for uint;

    event NewAdmin(address indexed newAdmin);
    event NewPendingAdmin(address indexed newPendingAdmin);
    event NewDelay(uint indexed newDelay);
    event CancelTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature,  bytes data, uint eta);
    event ExecuteTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature,  bytes data, uint eta);
    event QueueTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);

    uint public constant GRACE_PERIOD = 14 days;
    uint public constant MINIMUM_DELAY = 2 days;
    uint public constant MAXIMUM_DELAY = 30 days;

    address public admin;
    address public pendingAdmin;
    uint public delay;
    
    /// @notice Internally tracks clone deployment under eip-1167 proxy pattern
    bool private initialized;

    mapping (bytes32 => bool) public queuedTransactions;

    function init(address _admin, uint _delay) external {
        require(!initialized, "initialized");
        require(_delay >= MINIMUM_DELAY, "Timelock::constructor: Delay must exceed minimum delay.");
        require(_delay <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
        admin = _admin;
        delay = _delay;
        initialized = true;
    }

    function() external payable { }

    function setDelay(uint delay_) public {
        require(msg.sender == address(this), "Timelock::setDelay: Call must come from Timelock.");
        require(delay_ >= MINIMUM_DELAY, "Timelock::setDelay: Delay must exceed minimum delay.");
        require(delay_ <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
        delay = delay_;

        emit NewDelay(delay);
    }

    function acceptAdmin() public {
        require(msg.sender == pendingAdmin, "Timelock::acceptAdmin: Call must come from pendingAdmin.");
        admin = msg.sender;
        pendingAdmin = address(0);

        emit NewAdmin(admin);
    }

    function setPendingAdmin(address pendingAdmin_) public {
        require(msg.sender == address(this), "Timelock::setPendingAdmin: Call must come from Timelock.");
        pendingAdmin = pendingAdmin_;

        emit NewPendingAdmin(pendingAdmin);
    }

    function queueTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public returns (bytes32) {
        require(msg.sender == admin, "Timelock::queueTransaction: Call must come from admin.");
        require(eta >= getBlockTimestamp().add(delay), "Timelock::queueTransaction: Estimated execution block must satisfy delay.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = true;

        emit QueueTransaction(txHash, target, value, signature, data, eta);
        return txHash;
    }

    function cancelTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public {
        require(msg.sender == admin, "Timelock::cancelTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = false;

        emit CancelTransaction(txHash, target, value, signature, data, eta);
    }

    function executeTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public payable returns (bytes memory) {
        require(msg.sender == admin, "Timelock::executeTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        require(queuedTransactions[txHash], "Timelock::executeTransaction: Transaction hasn't been queued.");
        require(getBlockTimestamp() >= eta, "Timelock::executeTransaction: Transaction hasn't surpassed time lock.");
        require(getBlockTimestamp() <= eta.add(GRACE_PERIOD), "Timelock::executeTransaction: Transaction is stale.");

        queuedTransactions[txHash] = false;

        bytes memory callData;

        if (bytes(signature).length == 0) {
            callData = data;
        } else {
            callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
        }

        // solium-disable-next-line security/no-call-value
        (bool success, bytes memory returnData) = target.call.value(value)(callData);
        require(success, "Timelock::executeTransaction: Transaction execution reverted.");

        emit ExecuteTransaction(txHash, target, value, signature, data, eta);

        return returnData;
    }

    function getBlockTimestamp() internal view returns (uint) {
        // solium-disable-next-line security/no-block-members
        return block.timestamp;
    }
}

/// @notice Based on Compound Governance.
contract GovernanceToken {
    /// @notice EIP-20 token name for this token
    string public name;

    /// @notice EIP-20 token symbol for this token
    string public symbol;

    /// @notice EIP-20 token decimals for this token
    uint8 public constant decimals = 18;

    /// @notice Total number of tokens in circulation
    uint public totalSupply;

    /// @notice Allowance amounts on behalf of others
    mapping (address => mapping (address => uint96)) internal allowances;

    /// @notice Official record of token balances for each account
    mapping (address => uint96) internal balances;

    /// @notice A record of each accounts delegate
    mapping (address => address) public delegates;

    /// @notice A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint96 votes;
    }

    /// @notice A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @notice The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

    /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /// @notice The standard EIP-20 transfer event
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @notice The standard EIP-20 approval event
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /**
     * @notice Construct a new Comp token
     * @param account The initial account to grant all the tokens
     */
    constructor(address account, string memory _name, string memory _symbol, uint _totalSupply) public {
        balances[account] = uint96(_totalSupply);
        name = _name;
        symbol = _symbol;
        totalSupply = _totalSupply;
        emit Transfer(address(0), account, _totalSupply);
    }

    /**
     * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
     * @param account The address of the account holding the funds
     * @param spender The address of the account spending the funds
     * @return The number of tokens approved
     */
    function allowance(address account, address spender) external view returns (uint) {
        return allowances[account][spender];
    }

    /**
     * @notice Approve `spender` to transfer up to `amount` from `src`
     * @dev This will overwrite the approval amount for `spender`
     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
     * @param spender The address of the account which may transfer tokens
     * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
     * @return Whether or not the approval succeeded
     */
    function approve(address spender, uint rawAmount) external returns (bool) {
        uint96 amount;
        if (rawAmount == uint(-1)) {
            amount = uint96(-1);
        } else {
            amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");
        }

        allowances[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);
        return true;
    }

    /**
     * @notice Get the number of tokens held by the `account`
     * @param account The address of the account to get the balance of
     * @return The number of tokens held
     */
    function balanceOf(address account) external view returns (uint) {
        return balances[account];
    }

    /**
     * @notice Transfer `amount` tokens from `msg.sender` to `dst`
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transfer(address dst, uint rawAmount) external returns (bool) {
        uint96 amount = safe96(rawAmount, "Comp::transfer: amount exceeds 96 bits");
        _transferTokens(msg.sender, dst, amount);
        return true;
    }

    /**
     * @notice Transfer `amount` tokens from `src` to `dst`
     * @param src The address of the source account
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
        address spender = msg.sender;
        uint96 spenderAllowance = allowances[src][spender];
        uint96 amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");

        if (spender != src && spenderAllowance != uint96(-1)) {
            uint96 newAllowance = sub96(spenderAllowance, amount, "Comp::transferFrom: transfer amount exceeds spender allowance");
            allowances[src][spender] = newAllowance;

            emit Approval(src, spender, newAllowance);
        }

        _transferTokens(src, dst, amount);
        return true;
    }

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegatee The address to delegate votes to
     */
    function delegate(address delegatee) public {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
        bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
        bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "Comp::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "Comp::delegateBySig: invalid nonce");
        require(now <= expiry, "Comp::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @notice Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account) external view returns (uint96) {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @notice Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
        require(blockNumber < block.number, "Comp::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee) internal {
        address currentDelegate = delegates[delegator];
        uint96 delegatorBalance = balances[delegator];
        delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _transferTokens(address src, address dst, uint96 amount) internal {
        require(src != address(0), "Comp::_transferTokens: cannot transfer from the zero address");
        require(dst != address(0), "Comp::_transferTokens: cannot transfer to the zero address");

        balances[src] = sub96(balances[src], amount, "Comp::_transferTokens: transfer amount exceeds balance");
        balances[dst] = add96(balances[dst], amount, "Comp::_transferTokens: transfer amount overflows");
        emit Transfer(src, dst, amount);

        _moveDelegates(delegates[src], delegates[dst], amount);
    }

    function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint96 srcRepNew = sub96(srcRepOld, amount, "Comp::_moveVotes: vote amount underflows");
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint96 dstRepNew = add96(dstRepOld, amount, "Comp::_moveVotes: vote amount overflows");
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
      uint32 blockNumber = safe32(block.number, "Comp::_writeCheckpoint: block number exceeds 32 bits");

      if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
          checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
      } else {
          checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
          numCheckpoints[delegatee] = nCheckpoints + 1;
      }

      emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
        require(n < 2**96, errorMessage);
        return uint96(n);
    }

    function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        uint96 c = a + b;
        require(c >= a, errorMessage);
        return c;
    }

    function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        require(b <= a, errorMessage);
        return a - b;
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

/// @notice Based on Compound Governance.
contract GovernorAlpha {
    /// @notice The name of this contract
    string public name;

    /// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
    uint public quorumVotes;

    /// @notice The number of votes required in order for a voter to become a proposer
    uint public proposalThreshold;
    
    /// @notice The duration of voting on a proposal, in blocks
    uint public votingPeriod;

    /// @notice The maximum number of actions that can be included in a proposal
    function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions

    /// @notice The delay before voting on a proposal may take place, once proposed
    function votingDelay() public pure returns (uint) { return 1; } // 1 block

    /// @notice The address of the Governance Timelock
    TimelockInterface public timelock;

    /// @notice The address of the Governance token
    CompInterface public token;

    /// @notice The address of the Governance Guardian
    address public guardian;

    /// @notice The total number of proposals
    uint public proposalCount;
    
    /// @notice Internally tracks clone deployment under eip-1167 proxy pattern
    bool private initialized;

    struct Proposal {
        /// @notice Unique id for looking up a proposal
        uint id;

        /// @notice Creator of the proposal
        address proposer;

        /// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
        uint eta;

        /// @notice the ordered list of target addresses for calls to be made
        address[] targets;

        /// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
        uint[] values;

        /// @notice The ordered list of function signatures to be called
        string[] signatures;

        /// @notice The ordered list of calldata to be passed to each call
        bytes[] calldatas;

        /// @notice The block at which voting begins: holders must delegate their votes prior to this block
        uint startBlock;

        /// @notice The block at which voting ends: votes must be cast prior to this block
        uint endBlock;

        /// @notice Current number of votes in favor of this proposal
        uint forVotes;

        /// @notice Current number of votes in opposition to this proposal
        uint againstVotes;

        /// @notice Flag marking whether the proposal has been canceled
        bool canceled;

        /// @notice Flag marking whether the proposal has been executed
        bool executed;

        /// @notice Receipts of ballots for the entire set of voters
        mapping (address => Receipt) receipts;
    }

    /// @notice Ballot receipt record for a voter
    struct Receipt {
        /// @notice Whether or not a vote has been cast
        bool hasVoted;

        /// @notice Whether or not the voter supports the proposal
        bool support;

        /// @notice The number of votes the voter had, which were cast
        uint96 votes;
    }

    /// @notice Possible states that a proposal may be in
    enum ProposalState {
        Pending,
        Active,
        Canceled,
        Defeated,
        Succeeded,
        Queued,
        Expired,
        Executed
    }

    /// @notice The official record of all proposals ever proposed
    mapping (uint => Proposal) public proposals;

    /// @notice The latest proposal for each proposer
    mapping (address => uint) public latestProposalIds;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the ballot struct used by the contract
    bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");

    /// @notice An event emitted when a new proposal is created
    event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);

    /// @notice An event emitted when a vote has been cast on a proposal
    event VoteCast(address voter, uint proposalId, bool support, uint votes);

    /// @notice An event emitted when a proposal has been canceled
    event ProposalCanceled(uint id);

    /// @notice An event emitted when a proposal has been queued in the Timelock
    event ProposalQueued(uint id, uint eta);

    /// @notice An event emitted when a proposal has been executed in the Timelock
    event ProposalExecuted(uint id);

    function init(address _timelock, address _token, address _guardian, string calldata _name, uint _quorumVotes, uint _proposalThreshold, uint _votingPeriod) external {
        require(!initialized, "initialized");
        timelock = TimelockInterface(_timelock);
        token = CompInterface(_token);
        guardian = _guardian;
        name = _name;
        quorumVotes = _quorumVotes;
        proposalThreshold = _proposalThreshold;
        votingPeriod = _votingPeriod;
        initialized = true;
    }

    function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
        require(token.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold, "GovernorAlpha::propose: proposer votes below proposal threshold");
        require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
        require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
        require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");

        uint latestProposalId = latestProposalIds[msg.sender];
        if (latestProposalId != 0) {
          ProposalState proposersLatestProposalState = state(latestProposalId);
          require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
          require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
        }

        uint startBlock = add256(block.number, votingDelay());
        uint endBlock = add256(startBlock, votingPeriod);

        proposalCount++;
        Proposal memory newProposal = Proposal({
            id: proposalCount,
            proposer: msg.sender,
            eta: 0,
            targets: targets,
            values: values,
            signatures: signatures,
            calldatas: calldatas,
            startBlock: startBlock,
            endBlock: endBlock,
            forVotes: 0,
            againstVotes: 0,
            canceled: false,
            executed: false
        });

        proposals[newProposal.id] = newProposal;
        latestProposalIds[newProposal.proposer] = newProposal.id;

        emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
        return newProposal.id;
    }

    function queue(uint proposalId) public {
        require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
        Proposal storage proposal = proposals[proposalId];
        uint eta = add256(block.timestamp, timelock.delay());
        for (uint i = 0; i < proposal.targets.length; i++) {
            _queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
        }
        proposal.eta = eta;
        emit ProposalQueued(proposalId, eta);
    }

    function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
        require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
        timelock.queueTransaction(target, value, signature, data, eta);
    }

    function execute(uint proposalId) public payable {
        require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
        Proposal storage proposal = proposals[proposalId];
        proposal.executed = true;
        for (uint i = 0; i < proposal.targets.length; i++) {
            timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
        }
        emit ProposalExecuted(proposalId);
    }

    function cancel(uint proposalId) public {
        ProposalState state = state(proposalId);
        require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");

        Proposal storage proposal = proposals[proposalId];
        require(msg.sender == guardian || token.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold, "GovernorAlpha::cancel: proposer above threshold");

        proposal.canceled = true;
        for (uint i = 0; i < proposal.targets.length; i++) {
            timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
        }

        emit ProposalCanceled(proposalId);
    }

    function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
        Proposal storage p = proposals[proposalId];
        return (p.targets, p.values, p.signatures, p.calldatas);
    }

    function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
        return proposals[proposalId].receipts[voter];
    }

    function state(uint proposalId) public view returns (ProposalState) {
        require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");
        Proposal storage proposal = proposals[proposalId];
        if (proposal.canceled) {
            return ProposalState.Canceled;
        } else if (block.number <= proposal.startBlock) {
            return ProposalState.Pending;
        } else if (block.number <= proposal.endBlock) {
            return ProposalState.Active;
        } else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes) {
            return ProposalState.Defeated;
        } else if (proposal.eta == 0) {
            return ProposalState.Succeeded;
        } else if (proposal.executed) {
            return ProposalState.Executed;
        } else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
            return ProposalState.Expired;
        } else {
            return ProposalState.Queued;
        }
    }

    function castVote(uint proposalId, bool support) public {
        return _castVote(msg.sender, proposalId, support);
    }

    function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
        bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
        bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
        return _castVote(signatory, proposalId, support);
    }

    function _castVote(address voter, uint proposalId, bool support) internal {
        require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
        Proposal storage proposal = proposals[proposalId];
        Receipt storage receipt = proposal.receipts[voter];
        require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
        uint96 votes = token.getPriorVotes(voter, proposal.startBlock);

        if (support) {
            proposal.forVotes = add256(proposal.forVotes, votes);
        } else {
            proposal.againstVotes = add256(proposal.againstVotes, votes);
        }

        receipt.hasVoted = true;
        receipt.support = support;
        receipt.votes = votes;

        emit VoteCast(voter, proposalId, support, votes);
    }

    function __acceptAdmin() public {
        require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
        timelock.acceptAdmin();
    }

    function __abdicate() public {
        require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
        guardian = address(0);
    }

    function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
        require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
        timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
    }

    function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
        require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
        timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
    }

    function add256(uint256 a, uint256 b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "addition overflow");
        return c;
    }

    function sub256(uint256 a, uint256 b) internal pure returns (uint) {
        require(b <= a, "subtraction underflow");
        return a - b;
    }

    function getChainId() internal pure returns (uint) {
        uint chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

interface TimelockInterface {
    function delay() external view returns (uint);
    function GRACE_PERIOD() external view returns (uint);
    function acceptAdmin() external;
    function queuedTransactions(bytes32 hash) external view returns (bool);
    function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
    function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
    function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}

interface CompInterface {
    function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}

/*
The MIT License (MIT)
Copyright (c) 2018 Murray Software, LLC.
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.
*/
//solhint-disable max-line-length
//solhint-disable no-inline-assembly

contract CloneFactory {

  function createClone(address target) internal returns (address payable result) { // adapted for 'payable' clones
    bytes20 targetBytes = bytes20(target);
    assembly {
      let clone := mload(0x40)
      mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
      mstore(add(clone, 0x14), targetBytes)
      mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
      result := create(0, clone, 0x37)
    }
  }

  function isClone(address target, address query) internal view returns (bool result) {
    bytes20 targetBytes = bytes20(target);
    assembly {
      let clone := mload(0x40)
      mstore(clone, 0x363d3d373d3d3d363d7300000000000000000000000000000000000000000000)
      mstore(add(clone, 0xa), targetBytes)
      mstore(add(clone, 0x1e), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)

      let other := add(clone, 0x40)
      extcodecopy(query, other, 0, 0x2d)
      result := and(
        eq(mload(clone), mload(other)),
        eq(mload(add(clone, 0xd)), mload(add(other, 0xd)))
      )
    }
  }
}

contract GovernanceFactory is CloneFactory {
    address public timeLockTemplate;
    address public governorAlphaTemplate;
    
    event DeployGovernance(address indexed token, address indexed timelock, address indexed governor);
    
    constructor(address _timeLockTemplate, address _governorAlphaTemplate) public {
        timeLockTemplate = _timeLockTemplate;
        governorAlphaTemplate = _governorAlphaTemplate;
    }
    
    function deployGovernance(address admin, string calldata _name, string calldata _symbol, uint _totalSupply, uint timeLockDelay, uint _quorumVotes, uint _proposalThreshold, uint _votingPeriod) external {
        /// @dev Initialize governance token.
        GovernanceToken token = new GovernanceToken(admin, _name, _symbol, _totalSupply);
        /// @dev Initialize timelock clone.
        address timelock = initTimeLock(admin, timeLockDelay);
        /// @dev Initialize governor clone.
        address governor = initGovernor(timelock, address(token), admin, _name, _quorumVotes, _proposalThreshold, _votingPeriod);
        emit DeployGovernance(address(token), timelock, governor);
    }
    
    function initTimeLock(address admin, uint timeLockDelay) private returns (address payable timelock) {
        timelock = address(createClone(timeLockTemplate));
        Timelock(timelock).init(admin, timeLockDelay);
    }
    
    function initGovernor(address timelock, address token, address admin, string memory _name, uint _quorumVotes, uint _proposalThreshold, uint _votingPeriod) private returns (address governor) {
        governor = address(GovernorAlpha(createClone(governorAlphaTemplate)));
        GovernorAlpha(governor).init(timelock, token, admin, _name, _quorumVotes, _proposalThreshold, _votingPeriod);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint256","name":"_totalSupply","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":true,"inputs":[],"name":"DELEGATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"checkpoints","outputs":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint96","name":"votes","type":"uint96"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

10981:12913:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;10981:12913:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11063:18;;;:::i;:::-;;;;;;;;;;;;;;;;14675:419;;;;;;;;;:::i;:::-;;;;;;;;11324:23;;;:::i;:::-;;;;;;;;12212:122;;;:::i;16217:672::-;;;;;;;;;:::i;11225:35::-;;;:::i;:::-;;;;;;;;11662:45;;;;;;;;;:::i;:::-;;;;;;;;17037:102;;;;;;;;;:::i;:::-;;12090:49;;;;;;;;;:::i;:::-;;;;;;;;15297:108;;;;;;;;;:::i;19216:1218::-;;;;;;;;;:::i;:::-;;;;;;;;12626:39;;;;;;;;;:::i;11142:20::-;;;:::i;15669:238::-;;;;;;;;;:::i;18563:222::-;;;;;;;;;:::i;17573:789::-;;;;;;;;;:::i;14061:136::-;;;;;;;;;:::i;12428:117::-;;;:::i;11951:70::-;;;;;;;;;:::i;:::-;;;;;;;;;11063:18;;;;;;;;;;;;;;;-1:-1:-1;;11063:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14675:419::-;14743:4;;-1:-1:-1;;14788:21:0;;14784:173;;;-1:-1:-1;;;14784:173:0;;;14887:58;14894:9;14887:58;;;;;;;;;;;;;;;;;:6;:58::i;:::-;14878:67;;14784:173;14980:10;14969:22;;;;:10;:22;;;;;;;;-1:-1:-1;;;;;14969:31:0;;;;;;;;;;;:40;;-1:-1:-1;;;;;;14969:40:0;-1:-1:-1;;;;;14969:40:0;;;;;15027:37;;14969:31;;14980:10;15027:37;;;;14969:40;;15027:37;;;;;;;;;;15082:4;15075:11;;;14675:419;;;;;:::o;11324:23::-;;;;:::o;12212:122::-;12254:80;;;;;;;;;;;;;;12212:122;:::o;16217:672::-;-1:-1:-1;;;;;16381:15:0;;16299:4;16381:15;;;:10;:15;;;;;;;;16334:10;16381:24;;;;;;;;;;16432:58;;;;;;;;;;;;16334:10;;-1:-1:-1;;;;;16381:24:0;;;;16299:4;;16432:58;;16439:9;;16432:58;;;;;;;:6;:58::i;:::-;16416:74;-1:-1:-1;;;;;;16507:14:0;;;;;;;;;;:48;;-1:-1:-1;;;;;;16525:30:0;;;;;16507:48;16503:311;;;16572:19;16594:96;16600:16;16618:6;16594:96;;;;;;;;;;;;;;;;;:5;:96::i;:::-;-1:-1:-1;;;;;16705:15:0;;;;;;;:10;:15;;;;;;;;:24;;;;;;;;;;;;;;:39;;-1:-1:-1;;;;;;16705:39:0;-1:-1:-1;;;;;16705:39:0;;;;;16766:36;16705:39;;-1:-1:-1;16705:24:0;;16766:36;;;;16705:39;;16766:36;;;;;;;;;;16503:311;;16826:33;16842:3;16847;16852:6;16826:15;:33::i;:::-;16877:4;16870:11;;;;;16217:672;;;;;;:::o;11225:35::-;11258:2;11225:35;:::o;11662:45::-;;;;;;;;;;;;-1:-1:-1;;;;;11662:45:0;;:::o;17037:102::-;17099:32;17109:10;17121:9;17099;:32::i;:::-;17037:102;:::o;12090:49::-;;;;;;;;;;;;;;;:::o;15297:108::-;-1:-1:-1;;;;;15380:17:0;15356:4;15380:17;;;:8;:17;;;;;;-1:-1:-1;;;;;15380:17:0;;15297:108::o;19216:1218::-;19295:6;19336:12;19322:11;:26;19314:78;;;;-1:-1:-1;;;19314:78:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19427:23:0;;19405:19;19427:23;;;:14;:23;;;;;;;;;19461:58;;19506:1;19499:8;;;;;19461:58;-1:-1:-1;;;;;19579:20:0;;;;;;:11;:20;;;;;;;;:38;-1:-1:-1;;19600:16:0;;19579:38;;;;;;;;;:48;;-1:-1:-1;;19575:147:0;;-1:-1:-1;;;;;19666:20:0;;;;;;:11;:20;;;;;;;;-1:-1:-1;;19687:16:0;;;;19666:38;;;;;;;;:44;-1:-1:-1;;;19666:44:0;;-1:-1:-1;;;;;19666:44:0;;-1:-1:-1;19659:51:0;;19575:147;-1:-1:-1;;;;;19783:20:0;;;;;;:11;:20;;;;;;;;:23;;;;;;;;:33;:23;:33;-1:-1:-1;;19779:88:0;;;19854:1;19847:8;;;;;19779:88;19879:12;-1:-1:-1;;19921:16:0;;19948:428;19963:5;19955:13;;:5;:13;;;19948:428;;;20027:1;20010:13;;;20009:19;;;20001:27;;20070:20;;:::i;:::-;-1:-1:-1;;;;;;20093:20:0;;;;;;:11;:20;;;;;;;;:28;;;;;;;;;;;;;20070:51;;;;;;;;;;;;;;;-1:-1:-1;;;20070:51:0;;;-1:-1:-1;;;;;20070:51:0;;;;;;;;;20140:27;;20136:229;;;20195:8;;;;-1:-1:-1;20188:15:0;;-1:-1:-1;;;;20188:15:0;20136:229;20229:12;;:26;;;-1:-1:-1;20225:140:0;;;20284:6;20276:14;;20225:140;;;20348:1;20339:6;:10;20331:18;;20225:140;19948:428;;;;;-1:-1:-1;;;;;;20393:20:0;;;;;;;;:11;:20;;;;;;;;:27;;;;;;;;;;;;;;:33;-1:-1:-1;;;20393:33:0;;-1:-1:-1;;;;;20393:33:0;;19216:1218;-1:-1:-1;;;19216:1218:0:o;12626:39::-;;;;;;;;;;;;;:::o;11142:20::-;;;;;;;;;;;;;;;-1:-1:-1;;11142:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15669:238;15734:4;15751:13;15767:59;15774:9;15767:59;;;;;;;;;;;;;;;;;:6;:59::i;:::-;15751:75;;15837:40;15853:10;15865:3;15870:6;15837:15;:40::i;:::-;-1:-1:-1;15895:4:0;;15669:238;-1:-1:-1;;;15669:238:0:o;18563:222::-;-1:-1:-1;;;;;18669:23:0;;18628:6;18669:23;;;:14;:23;;;;;;;;;18710:67;;18776:1;18710:67;;;-1:-1:-1;;;;;18729:20:0;;;;;;;;:11;:20;;;;;;;;-1:-1:-1;;18750:16:0;;;18729:38;;;;;;;;;;;:44;-1:-1:-1;;;18729:44:0;;-1:-1:-1;;;;;18729:44:0;;;-1:-1:-1;18563:222:0:o;17573:789::-;17689:23;12254:80;;;;;;;;;;;;;;17769:4;17753:22;;;;;;;;;;;;;;;17777:12;:10;:12::i;:::-;17799:4;17725:80;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;17725:80:0;;;17715:91;;;;;;17689:117;;17817:18;12474:71;;;;;;;;;;;;;;;17848:57;;17880:9;;17891:5;;17898:6;;17848:57;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;17848:57:0;;;17838:68;;;;;;17817:89;;17917:14;17973:15;17990:10;17944:57;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;17944:57:0;;;17934:68;;;;;;17917:85;;18013:17;18033:26;18043:6;18051:1;18054;18057;18033:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;18033:26:0;;-1:-1:-1;;18033:26:0;;;-1:-1:-1;;;;;;;18078:23:0;;18070:74;;;;-1:-1:-1;;;18070:74:0;;;;;;;;;-1:-1:-1;;;;;18172:17:0;;;;;;:6;:17;;;;;:19;;-1:-1:-1;18172:19:0;;;;;18163:28;;18155:75;;;;-1:-1:-1;;;18155:75:0;;;;;;;;;18256:6;18249:3;:13;;18241:64;;;;-1:-1:-1;;;18241:64:0;;;;;;;;;18323:31;18333:9;18344;18323;:31::i;:::-;18316:38;;;;17573:789;;;;;;;:::o;14061:136::-;-1:-1:-1;;;;;14161:19:0;;;14137:4;14161:19;;;:10;:19;;;;;;;;:28;;;;;;;;;;;;-1:-1:-1;;;;;14161:28:0;;14061:136::o;12428:117::-;12474:71;;;;;;11951:70;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11951:70:0;;-1:-1:-1;;;;;11951:70:0;;:::o;23200:161::-;23275:6;23313:12;-1:-1:-1;;;23302:9:0;;23294:32;;;;-1:-1:-1;;;23294:32:0;;;;;;;;;;-1:-1:-1;23351:1:0;;23200:161;-1:-1:-1;;23200:161:0:o;23565:165::-;23651:6;23686:12;-1:-1:-1;;;;;23678:6:0;;;;;;;;23670:29;;;;-1:-1:-1;;;23670:29:0;;;;;;;;;;-1:-1:-1;;;23717:5:0;;;23565:165::o;20825:614::-;-1:-1:-1;;;;;20919:17:0;;20911:90;;;;-1:-1:-1;;;20911:90:0;;;;;;;;;-1:-1:-1;;;;;21020:17:0;;21012:88;;;;-1:-1:-1;;;21012:88:0;;;;;;;;;-1:-1:-1;;;;;21135:13:0;;;;;;:8;:13;;;;;;;;;;21129:86;;;;;;;;;;;;;;-1:-1:-1;;;;;21135:13:0;;;;21150:6;;21129:86;;;;;;;:5;:86::i;:::-;-1:-1:-1;;;;;21113:13:0;;;;;;;:8;:13;;;;;;;;:102;;-1:-1:-1;;;;;;21113:102:0;-1:-1:-1;;;;;21113:102:0;;;;;;21248:13;;;;;;;;;;21242:80;;-1:-1:-1;21242:80:0;;;;;;;;;;;21248:13;;;;;21263:6;;21242:80;;;;;;;;:5;:80::i;:::-;-1:-1:-1;;;;;21226:13:0;;;;;;;:8;:13;;;;;;;:96;;-1:-1:-1;;;;;;21226:96:0;-1:-1:-1;;;;;21226:96:0;;;;;;;;;;;21338:26;;;;;;;;;;21357:6;;21338:26;;;;;;;;;;-1:-1:-1;;;;;21392:14:0;;;;;;;:9;:14;;;;;;;21408;;;;;;;;21377:54;;21392:14;;;;21408;21424:6;21377:14;:54::i;:::-;20825:614;;;:::o;20442:375::-;-1:-1:-1;;;;;20545:20:0;;;20519:23;20545:20;;;:9;:20;;;;;;;;;;20602:8;:19;;;;;;20632:20;;;;:32;;;-1:-1:-1;;;;;;20632:32:0;;;;;;;20682:54;;20545:20;;;;;-1:-1:-1;;;;;20602:19:0;;;;20632:32;;20545:20;;;20682:54;;20519:23;20682:54;20749:60;20764:15;20781:9;20792:16;20749:14;:60::i;:::-;20442:375;;;;:::o;23738:153::-;23848:9;23738:153;:::o;23369:188::-;23455:6;23485:5;;;23517:12;-1:-1:-1;;;;;23509:6:0;;;;;;;;23501:29;;;;-1:-1:-1;;;23501:29:0;;;;;;;;;;-1:-1:-1;23548:1:0;23369:188;-1:-1:-1;;;;23369:188:0:o;21447:939::-;-1:-1:-1;;;;;21542:16:0;;;;;;;;;;:30;;-1:-1:-1;;;;;;21562:10:0;;;;21542:30;21538:841;;;-1:-1:-1;;;;;21593:20:0;;;21589:382;;-1:-1:-1;;;;;21653:22:0;;21634:16;21653:22;;;:14;:22;;;;;;;;;;21713:60;;21772:1;21713:60;;;-1:-1:-1;;;;;21729:19:0;;;;;;:11;:19;;;;;;;;-1:-1:-1;;21749:13:0;;21729:34;;;;;;;;;:40;-1:-1:-1;;;21729:40:0;;-1:-1:-1;;;;;21729:40:0;21713:60;21694:79;;21792:16;21811:68;21817:9;21828:6;21811:68;;;;;;;;;;;;;;;;;:5;:68::i;:::-;21792:87;;21898:57;21915:6;21923:9;21934;21945;21898:16;:57::i;:::-;21589:382;;;;-1:-1:-1;;;;;21991:20:0;;;21987:381;;-1:-1:-1;;;;;22051:22:0;;22032:16;22051:22;;;:14;:22;;;;;;;;;;22111:60;;22170:1;22111:60;;;-1:-1:-1;;;;;22127:19:0;;;;;;:11;:19;;;;;;;;-1:-1:-1;;22147:13:0;;22127:34;;;;;;;;;:40;-1:-1:-1;;;22127:40:0;;-1:-1:-1;;;;;22127:40:0;22111:60;22092:79;;22190:16;22209:67;22215:9;22226:6;22209:67;;;;;;;;;;;;;;;;;:5;:67::i;:::-;22190:86;;22295:57;22312:6;22320:9;22331;22342;22394:629;22512:18;22533:76;22540:12;22533:76;;;;;;;;;;;;;;;;;:6;:76::i;:::-;22512:97;;22639:1;22624:12;:16;;;:85;;;;-1:-1:-1;;;;;;22644:22:0;;;;;;:11;:22;;;;;;;;:65;-1:-1:-1;;22667:16:0;;22644:40;;;;;;;;;:50;:65;;;:50;;:65;22624:85;22620:329;;;-1:-1:-1;;;;;22724:22:0;;;;;;:11;:22;;;;;;;;-1:-1:-1;;22747:16:0;;22724:40;;;;;;;;;:57;;-1:-1:-1;;22724:57:0;-1:-1:-1;;;;;;;;22724:57:0;;;;;;22620:329;;;22849:33;;;;;;;;;;;;;;-1:-1:-1;;;;;22849:33:0;;;;;;;;;;-1:-1:-1;;;;;22810:22:0;;-1:-1:-1;22810:22:0;;;:11;:22;;;;;:36;;;;;;;;;;:72;;;;;;-1:-1:-1;;22810:72:0;;;;;;;;;;-1:-1:-1;;22810:72:0;-1:-1:-1;;;22810:72:0;;;;;;;;;;;;22895:25;;;:14;:25;;;;;;;:44;;;;;-1:-1:-1;22923:16:0;;22895:44;;;;;;;;;22620:329;22964:51;;-1:-1:-1;;;;;22964:51:0;;;;;;;22996:8;;23006;;22964:51;;;;;;;;;;22394:629;;;;;:::o;23031:161::-;23106:6;23144:12;-1:-1:-1;;;23133:9:0;;23125:32;;;;-1:-1:-1;;;23125:32:0;;;;;;;;;10981:12913;;;;;;;;;;-1:-1:-1;10981:12913:0;;;;;;;;:::o;5:130:-1:-;72:20;;97:33;72:20;97:33;;142:130;209:20;;234:33;209:20;234:33;;416:128;482:20;;507:32;482:20;507:32;;551:126;616:20;;641:31;616:20;641:31;;684:241;;788:2;776:9;767:7;763:23;759:32;756:2;;;804:1;801;794:12;756:2;839:1;856:53;901:7;881:9;856:53;;;846:63;750:175;-1:-1;;;;750:175;932:366;;;1053:2;1041:9;1032:7;1028:23;1024:32;1021:2;;;1069:1;1066;1059:12;1021:2;1104:1;1121:53;1166:7;1146:9;1121:53;;;1111:63;;1083:97;1211:2;1229:53;1274:7;1265:6;1254:9;1250:22;1229:53;;;1219:63;;1190:98;1015:283;;;;;;1305:491;;;;1443:2;1431:9;1422:7;1418:23;1414:32;1411:2;;;1459:1;1456;1449:12;1411:2;1494:1;1511:53;1556:7;1536:9;1511:53;;;1501:63;;1473:97;1601:2;1619:53;1664:7;1655:6;1644:9;1640:22;1619:53;;;1609:63;;1580:98;1709:2;1727:53;1772:7;1763:6;1752:9;1748:22;1727:53;;;1717:63;;1688:98;1405:391;;;;;;1803:366;;;1924:2;1912:9;1903:7;1899:23;1895:32;1892:2;;;1940:1;1937;1930:12;1892:2;1975:1;1992:53;2037:7;2017:9;1992:53;;;1982:63;;1954:97;2082:2;2100:53;2145:7;2136:6;2125:9;2121:22;2100:53;;2176:865;;;;;;;2363:3;2351:9;2342:7;2338:23;2334:33;2331:2;;;2380:1;2377;2370:12;2331:2;2415:1;2432:53;2477:7;2457:9;2432:53;;;2422:63;;2394:97;2522:2;2540:53;2585:7;2576:6;2565:9;2561:22;2540:53;;;2530:63;;2501:98;2630:2;2648:53;2693:7;2684:6;2673:9;2669:22;2648:53;;;2638:63;;2609:98;2738:2;2756:51;2799:7;2790:6;2779:9;2775:22;2756:51;;;2746:61;;2717:96;2844:3;2863:53;2908:7;2899:6;2888:9;2884:22;2863:53;;;2853:63;;2823:99;2953:3;2972:53;3017:7;3008:6;2997:9;2993:22;2972:53;;;2962:63;;2932:99;2325:716;;;;;;;;;3048:364;;;3168:2;3156:9;3147:7;3143:23;3139:32;3136:2;;;3184:1;3181;3174:12;3136:2;3219:1;3236:53;3281:7;3261:9;3236:53;;;3226:63;;3198:97;3326:2;3344:52;3388:7;3379:6;3368:9;3364:22;3344:52;;3419:113;3502:24;3520:5;3502:24;;;3497:3;3490:37;3484:48;;;3539:104;3616:21;3631:5;3616:21;;3650:113;3733:24;3751:5;3733:24;;3770:152;3871:45;3891:24;3909:5;3891:24;;;3871:45;;3952:887;;4091:5;4085:12;4125:1;4114:9;4110:17;4138:1;4133:267;;;;4411:1;4406:427;;;;4103:730;;4133:267;4211:4;4207:1;4196:9;4192:17;4188:28;4230:88;4311:6;4306:3;4230:88;;;-1:-1;;4337:25;;4325:38;;;-1:-1;4377:16;;;-1:-1;4133:267;;4406:427;4475:1;4464:9;4460:17;4491:88;4572:6;4567:3;4491:88;;;4484:95;;4601:41;4636:5;4601:41;;;4658:1;4666:130;4680:6;4677:1;4674:13;4666:130;;;4739:14;;4726:11;;;4719:35;4786:1;4773:15;;;;4702:4;4695:12;4666:130;;;-1:-1;;4810:16;;;-1:-1;4103:730;;4061:778;;;;;;4847:347;;4959:39;4992:5;4959:39;;;5010:71;5074:6;5069:3;5010:71;;;5003:78;;5086:52;5131:6;5126:3;5119:4;5112:5;5108:16;5086:52;;;5159:29;5181:6;5159:29;;;5150:39;;;;4939:255;-1:-1;;;4939:255;5548:375;;5708:67;5772:2;5767:3;5708:67;;;5808:34;5788:55;;-1:-1;;;5872:2;5863:12;;5856:30;5914:2;5905:12;;;-1:-1;;5694:229;5932:375;;6092:67;6156:2;6151:3;6092:67;;;6192:34;6172:55;;-1:-1;;;6256:2;6247:12;;6240:30;6298:2;6289:12;;;-1:-1;;6078:229;6316:398;;6494:84;6576:1;6571:3;6494:84;;;-1:-1;;;6591:87;;6706:1;6697:11;;;-1:-1;;6480:234;6723:376;;6883:67;6947:2;6942:3;6883:67;;;6983:34;6963:55;;-1:-1;;;7047:2;7038:12;;7031:31;7090:2;7081:12;;;-1:-1;;6869:230;7108:371;;7268:67;7332:2;7327:3;7268:67;;;7368:34;7348:55;;-1:-1;;;7432:2;7423:12;;7416:26;7470:2;7461:12;;;-1:-1;;7254:225;7488:395;;7648:67;7712:2;7707:3;7648:67;;;7748:34;7728:55;;7817:28;7812:2;7803:12;;7796:50;7874:2;7865:12;;7634:249;-1:-1;;7634:249;7892:477;;8070:85;8152:2;8147:3;8070:85;;;8188:34;8168:55;;8257:34;8252:2;8243:12;;8236:56;-1:-1;;;8321:2;8312:12;;8305:27;8360:2;8351:12;;;-1:-1;;8056:313;8378:397;;8538:67;8602:2;8597:3;8538:67;;;8638:34;8618:55;;8707:30;8702:2;8693:12;;8686:52;8766:2;8757:12;;8524:251;-1:-1;;8524:251;8784:431;;8962:85;9044:2;9039:3;8962:85;;;9080:34;9060:55;;9149:28;9144:2;9135:12;;9128:50;9206:2;9197:12;;8948:267;-1:-1;;8948:267;9343:110;9424:23;9441:5;9424:23;;9460:107;9539:22;9555:5;9539:22;;9574:124;9656:36;9686:5;9656:36;;9705:110;9786:23;9803:5;9786:23;;9822:264;;9967:94;10057:3;10048:6;9967:94;;10093:650;;10348:148;10492:3;10348:148;;;10341:155;;10507:75;10578:3;10569:6;10507:75;;;10604:2;10599:3;10595:12;10588:19;;10618:75;10689:3;10680:6;10618:75;;;-1:-1;10715:2;10706:12;;10329:414;-1:-1;;10329:414;10750:372;;10949:148;11093:3;10949:148;;11129:372;;11328:148;11472:3;11328:148;;11508:213;11626:2;11611:18;;11640:71;11615:9;11684:6;11640:71;;11728:201;11840:2;11825:18;;11854:65;11829:9;11892:6;11854:65;;11936:213;12054:2;12039:18;;12068:71;12043:9;12112:6;12068:71;;12156:547;12358:3;12343:19;;12373:71;12347:9;12417:6;12373:71;;;12455:72;12523:2;12512:9;12508:18;12499:6;12455:72;;;12538;12606:2;12595:9;12591:18;12582:6;12538:72;;;12621;12689:2;12678:9;12674:18;12665:6;12621:72;;;12329:374;;;;;;;;12710:547;12912:3;12897:19;;12927:71;12901:9;12971:6;12927:71;;;13009:72;13077:2;13066:9;13062:18;13053:6;13009:72;;;13092;13160:2;13149:9;13145:18;13136:6;13092:72;;;13175;13243:2;13232:9;13228:18;13219:6;13175:72;;13264:539;13462:3;13447:19;;13477:71;13451:9;13521:6;13477:71;;;13559:68;13623:2;13612:9;13608:18;13599:6;13559:68;;13810:293;13944:2;13958:47;;;13929:18;;14019:74;13929:18;14079:6;14019:74;;14418:407;14609:2;14623:47;;;14594:18;;14684:131;14594:18;14684:131;;14832:407;15023:2;15037:47;;;15008:18;;15098:131;15008:18;15098:131;;15246:407;15437:2;15451:47;;;15422:18;;15512:131;15422:18;15512:131;;15660:407;15851:2;15865:47;;;15836:18;;15926:131;15836:18;15926:131;;16074:407;16265:2;16279:47;;;16250:18;;16340:131;16250:18;16340:131;;16488:407;16679:2;16693:47;;;16664:18;;16754:131;16664:18;16754:131;;17122:209;17238:2;17223:18;;17252:69;17227:9;17294:6;17252:69;;17338:316;17480:2;17465:18;;17494:69;17469:9;17536:6;17494:69;;;17574:70;17640:2;17629:9;17625:18;17616:6;17574:70;;17661:205;17775:2;17760:18;;17789:67;17764:9;17829:6;17789:67;;17873:211;17990:2;17975:18;;18004:70;17979:9;18047:6;18004:70;;18091:209;18207:2;18192:18;;18221:69;18196:9;18263:6;18221:69;;18307:320;18451:2;18436:18;;18465:70;18440:9;18508:6;18465:70;;;18546:71;18613:2;18602:9;18598:18;18589:6;18546:71;;18634:161;;18732:14;;;18774:4;18761:18;;;18691:104;18802:118;18886:12;;18857:63;19057:144;19192:3;19170:31;-1:-1;19170:31;19210:163;19313:19;;;19362:4;19353:14;;19306:67;19535:91;;19597:24;19615:5;19597:24;;19633:85;19699:13;19692:21;;19675:43;19725:72;19787:5;19770:27;19804:121;-1:-1;;;;;19866:54;;19849:76;20011:88;20083:10;20072:22;;20055:44;20106:81;20177:4;20166:16;;20149:38;20194:104;-1:-1;;;;;20255:38;;20238:60;20305:106;;20383:23;20400:5;20383:23;;20419:268;20484:1;20491:101;20505:6;20502:1;20499:13;20491:101;;;20572:11;;;20566:18;20553:11;;;20546:39;20527:2;20520:10;20491:101;;;20607:6;20604:1;20601:13;20598:2;;;-1:-1;;20672:1;20654:16;;20647:27;20468:219;20776:97;20864:2;20844:14;-1:-1;;20840:28;;20824:49;20881:117;20950:24;20968:5;20950:24;;;20943:5;20940:35;20930:2;;20989:1;20986;20979:12;21005:117;21074:24;21092:5;21074:24;;21253:115;21321:23;21338:5;21321:23;;21375:113;21442:22;21458:5;21442:22;

bzzr://6f23f78bea0c7b130e731adebaf7e607503a07f261daa0444832c5c4fdac4148