Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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 MerkleLib
•    - function verifyProof(bytes32 root, by ...
•    - function parentHash(bytes32 a, bytes3 ...
•  contract MerkleResistor *
•    - function addMerkleTree(bytes32 newRoo ...
•    - function depositTokens(uint treeIndex ...
•    - function initialize(uint merkleIndex, ...
•    - function withdraw(uint merkleIndex, a ...
•    - function verifyVestingSchedule(uint m ...

More Options

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

/**
 *Submitted for verification at Etherscan.io on 2022-04-26
*/

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity 0.8.9;


/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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);
}

// This library is used to check merkle proofs very efficiently. Each additional proof element adds ~1000 gas
library MerkleLib {

    // This is the main function that will be called by contracts. It assumes the leaf is already hashed, as in,
    // it is not raw data but the hash of that. This is because the leaf data could be any combination of hashable
    // datatypes, so we let contracts hash the data themselves to keep this function simple
    function verifyProof(bytes32 root, bytes32 leaf, bytes32[] memory proof) public pure returns (bool) {
        bytes32 currentHash = leaf;

        // the proof is all siblings of the ancestors of the leaf (including the sibling of the leaf itself)
        // each iteration of this loop steps one layer higher in the merkle tree
        for (uint i = 0; i < proof.length; i += 1) {
            currentHash = parentHash(currentHash, proof[i]);
        }

        // does the result match the expected root? if so this leaf was committed to when the root was posted
        // else we must assume the data was not included
        return currentHash == root;
    }

    function parentHash(bytes32 a, bytes32 b) public pure returns (bytes32) {
        // the convention is that the inputs are sorted, this removes ambiguity about tree structure
        if (a < b) {
            return keccak256(abi.encode(a, b));
        } else {
            return keccak256(abi.encode(b, a));
        }
    }

}

// This contract is for user-chosen vesting schedules, within parameters selected by the tree creator
contract MerkleResistor {
    using MerkleLib for bytes32;

    // tree (vesting schedule) counter
    uint public numTrees = 0;

    // this represents a user chosen vesting schedule, post initiation
    struct Tranche {
        uint totalCoins; // total coins released after vesting complete
        uint currentCoins; // unclaimed coins remaining in the contract, waiting to be vested
        uint startTime; // start time of the vesting schedule
        uint endTime;   // end time of the vesting schedule
        uint coinsPerSecond;  // how many coins are emitted per second, this value is cached to avoid recomputing it
        uint lastWithdrawalTime; // keep track of last time user claimed coins to compute coins owed for this withdrawal
    }

    // this represents an arbitrarily large set of token recipients with partially-initialized vesting schedules
    struct MerkleTree {
        bytes32 merkleRoot; // merkle root of tree whose leaves are ranges of vesting schedules for each recipient
        bytes32 ipfsHash; // ipfs hash of the entire data set represented by the merkle root, in case our servers go down
        uint minEndTime; // minimum length (offset, not absolute) of vesting schedule in seconds
        uint maxEndTime; // maximum length (offset, not absolute) of vesting schedule in seconds
        uint pctUpFront; // percent of vested coins that will be available and withdrawn upon initialization
        address tokenAddress; // address of token to be distributed
        uint tokenBalance; // amount of tokens allocated to this tree (this prevents trees from sharing tokens)
    }

    // initialized[recipient][treeIndex] = hasUserChosenVestingSchedule
    // could have reused tranches (see below) for this but loading a bool is cheaper than loading an entire struct
    // NOTE: if a user appears in the same tree multiple times, the first leaf initialized will prevent the others from initializing
    mapping (address => mapping (uint => bool)) public initialized;

    // basically an array of vesting schedules, but without annoying solidity array syntax
    mapping (uint => MerkleTree) public merkleTrees;

    // tranches[recipient][treeIndex] = chosenVestingSchedule
    mapping (address => mapping (uint => Tranche)) public tranches;

    // precision factory used to handle floating point arithmetic
    uint constant public PRECISION = 1000000;

    // every time a withdrawal occurs
    event WithdrawalOccurred(address indexed destination, uint numTokens, uint tokensLeft, uint indexed merkleIndex);
    // every time a tree is added
    event MerkleTreeAdded(uint indexed index, address indexed tokenAddress, bytes32 newRoot, bytes32 ipfsHash);
    // every time a tree is topped up
    event TokensDeposited(uint indexed index, address indexed tokenAddress, uint amount);

    // anyone can add a tree
    function addMerkleTree(bytes32 newRoot, bytes32 ipfsHash, uint minEndTime, uint maxEndTime, uint pctUpFront, address depositToken, uint tokenBalance) public {
        // check basic coherence of request
        require(pctUpFront < 100, 'pctUpFront >= 100');
        require(minEndTime < maxEndTime, 'minEndTime must be less than maxEndTime');

        // prefix operator ++ increments then evaluates
        merkleTrees[++numTrees] = MerkleTree(
            newRoot,
            ipfsHash,
            minEndTime,
            maxEndTime,
            pctUpFront,
            depositToken,
            0    // tokenBalance is 0 at first because no tokens have been deposited
        );

        // pull tokens from user to fund the tree
        // if tree is insufficiently funded, then some users may not be able to be paid out, this is the responsibility
        // of the tree creator, if trees are not funded, then the UI will not display the tree
        depositTokens(numTrees, tokenBalance);
        emit MerkleTreeAdded(numTrees, depositToken, newRoot, ipfsHash);
    }

    // anyone can fund any tree
    function depositTokens(uint treeIndex, uint value) public {
        // storage because we edit
        MerkleTree storage merkleTree = merkleTrees[treeIndex];

        // bookkeeping to make sure trees do not share tokens
        merkleTree.tokenBalance += value;

        // do the transfer from the caller
        // NOTE: it is possible for user to overfund the tree and there is no mechanism to reclaim excess tokens
        // this is because there is no way for the contract to know when a tree has had all leaves claimed
        // there is also no way for the contract to know the minimum or maximum liabilities represented by the leaves
        // in short, there is no on-chain inspection of the leaves except at initialization time
        // NOTE: a malicious token contract could cause merkleTree.tokenBalance to be out of sync with the token contract
        // this is an unavoidable possibility, and it could render the tree unusable, while leaving other trees unharmed
        require(IERC20(merkleTree.tokenAddress).transferFrom(msg.sender, address(this), value), "ERC20 transfer failed");
        emit TokensDeposited(treeIndex, merkleTree.tokenAddress, value);
    }

    // user calls this to choose and start their vesting schedule
    // merkle proof confirms they are passing data previously committed to by tree creator
    // vestingTime is chosen by the user, min/max TotalPayments is committed to by the merkleRoot
    function initialize(uint merkleIndex, address destination, uint vestingTime, uint minTotalPayments, uint maxTotalPayments, bytes32[] memory proof) external {
        // user selects own vesting schedule, not others
        require(msg.sender == destination, 'Can only initialize your own tranche');
        // can only initialize once
        require(!initialized[destination][merkleIndex], "Already initialized");
        // compute merkle leaf, this is first element of proof
        bytes32 leaf = keccak256(abi.encode(destination, minTotalPayments, maxTotalPayments));
        // memory because we do not edit
        MerkleTree memory tree = merkleTrees[merkleIndex];
        // this calls into MerkleLib, super cheap ~1000 gas per proof element
        require(tree.merkleRoot.verifyProof(leaf, proof), "The proof could not be verified.");
        // mark tree as initialized, preventing re-entrance or multiple initializations
        initialized[destination][merkleIndex] = true;

        (bool valid, uint totalCoins, uint coinsPerSecond, uint startTime) = verifyVestingSchedule(merkleIndex, vestingTime, minTotalPayments, maxTotalPayments);
        require(valid, 'Invalid vesting schedule');

        // fill out the struct for the address' vesting schedule
        // don't have to mark as storage here, it's implied (why isn't it always implied when written to? solc-devs?)
        tranches[destination][merkleIndex] = Tranche(
            totalCoins,    // this is just a cached number for UI, not used
            totalCoins,    // starts out full
            startTime,     // start time will usually be in the past, if pctUpFront > 0
            block.timestamp + vestingTime,  // vesting starts from initialization time
            coinsPerSecond,  // cached value to avoid recomputation
            startTime      // this is lastWithdrawalTime, set to startTime to indicate no withdrawals have occurred yet
        );
        withdraw(merkleIndex, destination);
    }

    // user calls this to claim available (unclaimed, unlocked) tokens
    // NOTE: anyone can withdraw tokens for anyone else, but they always go to intended destination
    // msg.sender is not used in this function ;)
    function withdraw(uint merkleIndex, address destination) public {
        // initialize first, no operations on empty structs, I don't care if the values are "probably zero"
        require(initialized[destination][merkleIndex], "You must initialize your account first.");
        // storage, since we are editing
        Tranche storage tranche = tranches[destination][merkleIndex];
        // if it's empty, don't bother
        require(tranche.currentCoins >  0, 'No coins left to withdraw');
        uint currentWithdrawal = 0;

        // if after vesting period ends, give them the remaining coins, also avoids dust from rounding errors
        if (block.timestamp >= tranche.endTime) {
            currentWithdrawal = tranche.currentCoins;
        } else {
            // compute allowed withdrawal
            // secondsElapsedSinceLastWithdrawal * coinsPerSecond == coinsAccumulatedSinceLastWithdrawal
            currentWithdrawal = (block.timestamp - tranche.lastWithdrawalTime) * tranche.coinsPerSecond;
        }
        // muto? servo
        MerkleTree storage tree = merkleTrees[merkleIndex];

        // update struct, modern solidity will catch underflow and prevent currentWithdrawal from exceeding currentCoins
        // but it's computed internally anyway, not user generated
        tranche.currentCoins -= currentWithdrawal;
        // move the time counter up so users can't double-withdraw allocated coins
        // this also works as a re-entrance gate, so currentWithdrawal would be 0 upon re-entrance
        tranche.lastWithdrawalTime = block.timestamp;
        // handle the bookkeeping so trees don't share tokens, do it before transferring to create one more re-entrance gate
        tree.tokenBalance -= currentWithdrawal;

        // transfer the tokens, brah
        // NOTE: if this is a malicious token, what could happen?
        // 1/ token doesn't transfer given amount to recipient, this is bad for user, but does not effect other trees
        // 2/ token fails for some reason, again bad for user, but this does not effect other trees
        // 3/ token re-enters this function (or other, but this is the only one that transfers tokens out)
        // in which case, lastWithdrawalTime == block.timestamp, so currentWithdrawal == 0
        // besides msg.sender is not used in this function, so who calls it is irrelevant...
        require(IERC20(tree.tokenAddress).transfer(destination, currentWithdrawal), 'Token transfer failed');
        emit WithdrawalOccurred(destination, currentWithdrawal, tranche.currentCoins, merkleIndex);
    }

    // used to determine whether the vesting schedule is legit
    function verifyVestingSchedule(uint merkleIndex, uint vestingTime, uint minTotalPayments, uint maxTotalPayments) public view returns (bool, uint, uint, uint) {
        // vesting schedules for non-existing trees are invalid, I don't care how much you like uninitialized structs
        if (merkleIndex > numTrees) {
            return (false, 0, 0, 0);
        }

        // memory not storage, since we do not edit the tree, and it's a view function anyways
        MerkleTree memory tree = merkleTrees[merkleIndex];

        // vesting time must sit within the closed interval of [minEndTime, maxEndTime]
        if (vestingTime > tree.maxEndTime || vestingTime < tree.minEndTime) {
            return (false, 0, 0, 0);
        }

        uint totalCoins;
        if (vestingTime == tree.maxEndTime) {
            // this is to prevent dust accumulation from rounding errors
            // maxEndTime results in max payments, no further computation necessary
            totalCoins = maxTotalPayments;
        } else {
            // remember grade school algebra? slope = Δy / Δx
            // this is the slope of eligible vesting schedules. In general, 0 < m < 1,
            // (longer vesting schedules should result in less coins per second, hence "resistor")
            // so we multiply by a precision factor to reduce rounding errors
            // y axis = total coins released after vesting completed
            // x axis = length of vesting schedule
            // this is the line of valid end-points for the chosen vesting schedule line, see below
            // NOTE: this reverts if minTotalPayments > maxTotalPayments, which is a good thing
            uint paymentSlope = (maxTotalPayments - minTotalPayments) * PRECISION / (tree.maxEndTime - tree.minEndTime);

            // y = mx + b = paymentSlope * (x - x0) + y0
            // divide by precision factor here since we have completed the rounding error sensitive operations
            totalCoins = (paymentSlope * (vestingTime - tree.minEndTime) / PRECISION) + minTotalPayments;
        }

        // this is a different slope, the slope of their chosen vesting schedule
        // y axis = cumulative coins emitted
        // x axis = time elapsed
        // NOTE: vestingTime starts from block.timestamp, so doesn't include coins already available from pctUpFront
        // totalCoins / vestingTime is wrong, we have to multiple by the proportion of the coins that are indexed
        // by vestingTime, which is (100 - pctUpFront) / 100
        uint coinsPerSecond = (totalCoins * (uint(100) - tree.pctUpFront)) / (vestingTime * 100);

        // vestingTime is relative to initialization point
        // endTime = block.timestamp + vestingTime
        // vestingLength = totalCoins / coinsPerSecond
        uint startTime = block.timestamp + vestingTime - (totalCoins / coinsPerSecond);

        return (true, totalCoins, coinsPerSecond, startTime);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"bytes32","name":"newRoot","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"ipfsHash","type":"bytes32"}],"name":"MerkleTreeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensDeposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"destination","type":"address"},{"indexed":false,"internalType":"uint256","name":"numTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensLeft","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"merkleIndex","type":"uint256"}],"name":"WithdrawalOccurred","type":"event"},{"inputs":[],"name":"PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"newRoot","type":"bytes32"},{"internalType":"bytes32","name":"ipfsHash","type":"bytes32"},{"internalType":"uint256","name":"minEndTime","type":"uint256"},{"internalType":"uint256","name":"maxEndTime","type":"uint256"},{"internalType":"uint256","name":"pctUpFront","type":"uint256"},{"internalType":"address","name":"depositToken","type":"address"},{"internalType":"uint256","name":"tokenBalance","type":"uint256"}],"name":"addMerkleTree","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"treeIndex","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"depositTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"merkleIndex","type":"uint256"},{"internalType":"address","name":"destination","type":"address"},{"internalType":"uint256","name":"vestingTime","type":"uint256"},{"internalType":"uint256","name":"minTotalPayments","type":"uint256"},{"internalType":"uint256","name":"maxTotalPayments","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"initialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"merkleTrees","outputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"ipfsHash","type":"bytes32"},{"internalType":"uint256","name":"minEndTime","type":"uint256"},{"internalType":"uint256","name":"maxEndTime","type":"uint256"},{"internalType":"uint256","name":"pctUpFront","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenBalance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numTrees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"tranches","outputs":[{"internalType":"uint256","name":"totalCoins","type":"uint256"},{"internalType":"uint256","name":"currentCoins","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"uint256","name":"coinsPerSecond","type":"uint256"},{"internalType":"uint256","name":"lastWithdrawalTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"merkleIndex","type":"uint256"},{"internalType":"uint256","name":"vestingTime","type":"uint256"},{"internalType":"uint256","name":"minTotalPayments","type":"uint256"},{"internalType":"uint256","name":"maxTotalPayments","type":"uint256"}],"name":"verifyVestingSchedule","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"merkleIndex","type":"uint256"},{"internalType":"address","name":"destination","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b506004361061009d5760003560e01c8063aaf5eb6811610066578063aaf5eb68146101db578063c26cb54f146101e5578063d71383ed14610260578063f16ad51e14610273578063f287ad041461028657600080fd5b8062f714ce146100a2578063390b7c66146100b75780636fb6ec41146100d357806385d88cb11461010857806386bb82491461019d575b600080fd5b6100b56100b0366004610da0565b610299565b005b6100c060005481565b6040519081526020015b60405180910390f35b6100e66100e1366004610dcc565b61053c565b60408051941515855260208501939093529183015260608201526080016100ca565b61015f610116366004610dfe565b600260208190526000918252604090912080546001820154928201546003830154600484015460058501546006909501549395949293919290916001600160a01b039091169087565b60408051978852602088019690965294860193909352606085019190915260808401526001600160a01b031660a083015260c082015260e0016100ca565b6101cb6101ab366004610e17565b600160209081526000928352604080842090915290825290205460ff1681565b60405190151581526020016100ca565b6100c0620f424081565b6102336101f3366004610e17565b6003602081815260009384526040808520909152918352912080546001820154600283015493830154600484015460059094015492949193919290919086565b604080519687526020870195909552938501929092526060840152608083015260a082015260c0016100ca565b6100b561026e366004610e41565b6106e3565b6100b5610281366004610e9d565b6108a7565b6100b5610294366004610ed5565b6109ea565b6001600160a01b038116600090815260016020908152604080832085845290915290205460ff166103215760405162461bcd60e51b815260206004820152602760248201527f596f75206d75737420696e697469616c697a6520796f7572206163636f756e74604482015266103334b939ba1760c91b60648201526084015b60405180910390fd5b6001600160a01b0381166000908152600360209081526040808320858452909152902060018101546103955760405162461bcd60e51b815260206004820152601960248201527f4e6f20636f696e73206c65667420746f207769746864726177000000000000006044820152606401610318565b6000816003015442106103ad575060018101546103ce565b600482015460058301546103c19042610fe1565b6103cb9190610ff8565b90505b6000848152600260205260408120600184018054919284926103f1908490610fe1565b9091555050426005840155600681018054839190600090610413908490610fe1565b9091555050600581015460405163a9059cbb60e01b81526001600160a01b038681166004830152602482018590529091169063a9059cbb90604401602060405180830381600087803b15801561046857600080fd5b505af115801561047c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104a09190611017565b6104e45760405162461bcd60e51b8152602060048201526015602482015274151bdad95b881d1c985b9cd9995c8819985a5b1959605a1b6044820152606401610318565b84846001600160a01b03167f5ffb4b63dec15ba26308386f1d5ca61843b29ba365511062a887d95aa27532d384866001015460405161052d929190918252602082015260400190565b60405180910390a35050505050565b60008060008060005488111561055d575060009250829150819050806106d8565b600088815260026020818152604092839020835160e0810185528154815260018201549281019290925291820154928101929092526003810154606083018190526004820154608084015260058201546001600160a01b031660a084015260069091015460c08301528811806105d65750806040015188105b156105ef576000806000809450945094509450506106d8565b60008160600151891415610604575085610675565b60008260400151836060015161061a9190610fe1565b620f42406106288b8b610fe1565b6106329190610ff8565b61063c9190611040565b905088620f424084604001518c6106539190610fe1565b61065d9084610ff8565b6106679190611040565b6106719190611062565b9150505b60006106828a6064610ff8565b6080840151610692906064610fe1565b61069c9084610ff8565b6106a69190611040565b905060006106b48284611040565b6106be8c42611062565b6106c89190610fe1565b6001985092965090945090925050505b945094509450949050565b606483106107275760405162461bcd60e51b81526020600482015260116024820152700706374557046726f6e74203e3d2031303607c1b6044820152606401610318565b8385106107865760405162461bcd60e51b815260206004820152602760248201527f6d696e456e6454696d65206d757374206265206c657373207468616e206d6178604482015266456e6454696d6560c81b6064820152608401610318565b6040518060e00160405280888152602001878152602001868152602001858152602001848152602001836001600160a01b0316815260200160008152506002600080600081546107d59061107a565b918290555081526020808201929092526040908101600090812084518155928401516001840155908301516002830155606083015160038301556080830151600483015560a08301516005830180546001600160a01b0319166001600160a01b0390921691909117905560c0909201516006909101555461085690826108a7565b60005460408051898152602081018990526001600160a01b03851692917f7247d7268297fd9fe23a535b70f414660bbcbbcd73ac0d9ce3c103a356a61f45910160405180910390a350505050505050565b6000828152600260205260408120600681018054919284926108ca908490611062565b909155505060058101546040516323b872dd60e01b8152336004820152306024820152604481018490526001600160a01b03909116906323b872dd90606401602060405180830381600087803b15801561092357600080fd5b505af1158015610937573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061095b9190611017565b61099f5760405162461bcd60e51b8152602060048201526015602482015274115490cc8c081d1c985b9cd9995c8819985a5b1959605a1b6044820152606401610318565b60058101546040518381526001600160a01b039091169084907fb162210da7d23d82c18cff5af46d3562661d26b42a6848fa28d64a6bdc70386a9060200160405180910390a3505050565b336001600160a01b03861614610a4e5760405162461bcd60e51b8152602060048201526024808201527f43616e206f6e6c7920696e697469616c697a6520796f7572206f776e207472616044820152636e63686560e01b6064820152608401610318565b6001600160a01b038516600090815260016020908152604080832089845290915290205460ff1615610ab85760405162461bcd60e51b8152602060048201526013602482015272105b1c9958591e481a5b9a5d1a585b1a5e9959606a1b6044820152606401610318565b604080516001600160a01b03871660208201529081018490526060810183905260009060800160408051601f19818403018152828252805160209182012060008b815260028084529084902060e0860185528054808752600182015494870194909452908101548585015260038101546060860152600480820154608087015260058201546001600160a01b031660a087015260069091015460c08601529251632769cd1f60e21b815290945073458efd41740ffb27d86a9157050c0707b41e952092639da7347c92610b919290918791899101611095565b60206040518083038186803b158015610ba957600080fd5b505af4158015610bbd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610be19190611017565b610c2d5760405162461bcd60e51b815260206004820181905260248201527f5468652070726f6f6620636f756c64206e6f742062652076657269666965642e6044820152606401610318565b6001600160a01b03871660009081526001602081815260408084208c85529091528220805460ff19169091179055808080610c6a8c8b8b8b61053c565b935093509350935083610cbf5760405162461bcd60e51b815260206004820152601860248201527f496e76616c69642076657374696e67207363686564756c6500000000000000006044820152606401610318565b6040518060c001604052808481526020018481526020018281526020018b42610ce89190611062565b815260200183815260200182815250600360008d6001600160a01b03166001600160a01b0316815260200190815260200160002060008e8152602001908152602001600020600082015181600001556020820151816001015560408201518160020155606082015181600301556080820151816004015560a08201518160050155905050610d768c8c610299565b505050505050505050505050565b80356001600160a01b0381168114610d9b57600080fd5b919050565b60008060408385031215610db357600080fd5b82359150610dc360208401610d84565b90509250929050565b60008060008060808587031215610de257600080fd5b5050823594602084013594506040840135936060013592509050565b600060208284031215610e1057600080fd5b5035919050565b60008060408385031215610e2a57600080fd5b610e3383610d84565b946020939093013593505050565b600080600080600080600060e0888a031215610e5c57600080fd5b8735965060208801359550604088013594506060880135935060808801359250610e8860a08901610d84565b915060c0880135905092959891949750929550565b60008060408385031215610eb057600080fd5b50508035926020909101359150565b634e487b7160e01b600052604160045260246000fd5b60008060008060008060c08789031215610eee57600080fd5b863595506020610eff818901610d84565b955060408801359450606088013593506080880135925060a088013567ffffffffffffffff80821115610f3157600080fd5b818a0191508a601f830112610f4557600080fd5b813581811115610f5757610f57610ebf565b8060051b604051601f19603f83011681018181108582111715610f7c57610f7c610ebf565b60405291825284820192508381018501918d831115610f9a57600080fd5b938501935b82851015610fb857843584529385019392850192610f9f565b8096505050505050509295509295509295565b634e487b7160e01b600052601160045260246000fd5b600082821015610ff357610ff3610fcb565b500390565b600081600019048311821515161561101257611012610fcb565b500290565b60006020828403121561102957600080fd5b8151801515811461103957600080fd5b9392505050565b60008261105d57634e487b7160e01b600052601260045260246000fd5b500490565b6000821982111561107557611075610fcb565b500190565b600060001982141561108e5761108e610fcb565b5060010190565b6000606082018583526020858185015260606040850152818551808452608086019150828701935060005b818110156110dc578451835293830193918301916001016110c0565b50909897505050505050505056fea2646970667358221220687cdc8caf4759b312e18c50f8c293a8cd99dd62cbf7a80817e3194be09a150764736f6c63430008090033

MerkleLib : 0x458efd41740ffb27d86a9157050c0707b41e9520

4371:13454:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12132:2624;;;;;;:::i;:::-;;:::i;:::-;;4478:24;;;;;;;;;597:25:1;;;585:2;570:18;4478:24:0;;;;;;;;14828:2992;;;;;;:::i;:::-;;:::i;:::-;;;;1273:14:1;;1266:22;1248:41;;1320:2;1305:18;;1298:34;;;;1348:18;;;1341:34;1406:2;1391:18;;1384:34;1235:3;1220:19;14828:2992:0;1023:401:1;6507:47:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;6507:47:0;;;;;;;;;;1929:25:1;;;1985:2;1970:18;;1963:34;;;;2013:18;;;2006:34;;;;2071:2;2056:18;;2049:34;;;;2114:3;2099:19;;2092:35;-1:-1:-1;;;;;2164:32:1;2184:3;2143:19;;2136:61;2228:3;2213:19;;2206:35;1916:3;1901:19;6507:47:0;1614:633:1;6344:62:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2676:14:1;;2669:22;2651:41;;2639:2;2624:18;6344:62:0;2511:187:1;6764:40:0;;6797:7;6764:40;;6626:62;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2990:25:1;;;3046:2;3031:18;;3024:34;;;;3074:18;;;3067:34;;;;3132:2;3117:18;;3110:34;3175:3;3160:19;;3153:35;3219:3;3204:19;;3197:35;2977:3;2962:19;6626:62:0;2703:535:1;7281:1096:0;;;;;;:::i;:::-;;:::i;8418:1202::-;;;;;;:::i;:::-;;:::i;9886:2014::-;;;;;;:::i;:::-;;:::i;12132:2624::-;-1:-1:-1;;;;;12324:24:0;;;;;;:11;:24;;;;;;;;:37;;;;;;;;;;;12316:89;;;;-1:-1:-1;;;12316:89:0;;5902:2:1;12316:89:0;;;5884:21:1;5941:2;5921:18;;;5914:30;5980:34;5960:18;;;5953:62;-1:-1:-1;;;6031:18:1;;;6024:37;6078:19;;12316:89:0;;;;;;;;;-1:-1:-1;;;;;12484:21:0;;12458:23;12484:21;;;:8;:21;;;;;;;;:34;;;;;;;;12577:20;;;;12569:63;;;;-1:-1:-1;;;12569:63:0;;6310:2:1;12569:63:0;;;6292:21:1;6349:2;6329:18;;;6322:30;6388:27;6368:18;;;6361:55;6433:18;;12569:63:0;6108:349:1;12569:63:0;12643:22;12816:7;:15;;;12797;:34;12793:380;;-1:-1:-1;12868:20:0;;;;12793:380;;;13139:22;;;;13109:26;;;;13091:44;;:15;:44;:::i;:::-;13090:71;;;;:::i;:::-;13070:91;;12793:380;13207:23;13233:24;;;:11;:24;;;;;13460:20;;;:41;;13233:24;;13484:17;;13460:41;;13484:17;;13460:41;:::i;:::-;;;;-1:-1:-1;;13725:15:0;13696:26;;;:44;13877:17;;;:38;;13898:17;;13877;;;:38;;13898:17;;13877:38;:::i;:::-;;;;-1:-1:-1;;14562:17:0;;;;14555:66;;-1:-1:-1;;;14555:66:0;;-1:-1:-1;;;;;7089:32:1;;;14555:66:0;;;7071:51:1;7138:18;;;7131:34;;;14562:17:0;;;;14555:34;;7044:18:1;;14555:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14547:100;;;;-1:-1:-1;;;14547:100:0;;7660:2:1;14547:100:0;;;7642:21:1;7699:2;7679:18;;;7672:30;-1:-1:-1;;;7718:18:1;;;7711:51;7779:18;;14547:100:0;7458:345:1;14547:100:0;14736:11;14682;-1:-1:-1;;;;;14663:85:0;;14695:17;14714:7;:20;;;14663:85;;;;;;7982:25:1;;;8038:2;8023:18;;8016:34;7970:2;7955:18;;7808:248;14663:85:0;;;;;;;;12196:2560;;;12132:2624;;:::o;14828:2992::-;14962:4;14968;14974;14980;15134:8;;15120:11;:22;15116:78;;;-1:-1:-1;15167:5:0;;-1:-1:-1;15167:5:0;;-1:-1:-1;15167:5:0;;-1:-1:-1;15167:5:0;15159:23;;15116:78;15302:22;15327:24;;;:11;:24;;;;;;;;;15302:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15302:49:0;;;;;;;;;;;;;;15457:29;;;:62;;;15504:4;:15;;;15490:11;:29;15457:62;15453:118;;;15544:5;15551:1;15554;15557;15536:23;;;;;;;;;;;15453:118;15583:15;15628:4;:15;;;15613:11;:30;15609:1322;;;-1:-1:-1;15832:16:0;15609:1322;;;16533:17;16624:4;:15;;;16606:4;:15;;;:33;;;;:::i;:::-;6797:7;16554:35;16573:16;16554;:35;:::i;:::-;16553:49;;;;:::i;:::-;:87;;;;:::i;:::-;16533:107;;16903:16;6797:7;16871:4;:15;;;16857:11;:29;;;;:::i;:::-;16841:46;;:12;:46;:::i;:::-;:58;;;;:::i;:::-;16840:79;;;;:::i;:::-;16827:92;;15866:1065;15609:1322;17400:19;17470:17;:11;17484:3;17470:17;:::i;:::-;17449:15;;;;17437:27;;17442:3;17437:27;:::i;:::-;17423:42;;:10;:42;:::i;:::-;17422:66;;;;:::i;:::-;17400:88;-1:-1:-1;17669:14:0;17719:27;17400:88;17719:10;:27;:::i;:::-;17686:29;17704:11;17686:15;:29;:::i;:::-;:61;;;;:::i;:::-;17768:4;;-1:-1:-1;17774:10:0;;-1:-1:-1;17786:14:0;;-1:-1:-1;17669:78:0;;-1:-1:-1;;;14828:2992:0;;;;;;;;;;:::o;7281:1096::-;7515:3;7502:10;:16;7494:46;;;;-1:-1:-1;;;7494:46:0;;8618:2:1;7494:46:0;;;8600:21:1;8657:2;8637:18;;;8630:30;-1:-1:-1;;;8676:18:1;;;8669:47;8733:18;;7494:46:0;8416:341:1;7494:46:0;7572:10;7559;:23;7551:75;;;;-1:-1:-1;;;7551:75:0;;8964:2:1;7551:75:0;;;8946:21:1;9003:2;8983:18;;;8976:30;9042:34;9022:18;;;9015:62;-1:-1:-1;;;9093:18:1;;;9086:37;9140:19;;7551:75:0;8762:403:1;7551:75:0;7722:255;;;;;;;;7747:7;7722:255;;;;7769:8;7722:255;;;;7792:10;7722:255;;;;7817:10;7722:255;;;;7842:10;7722:255;;;;7867:12;-1:-1:-1;;;;;7722:255:0;;;;;7894:1;7722:255;;;7696:11;:23;7710:8;;7708:10;;;;;:::i;:::-;;;;;-1:-1:-1;7696:23:0;;;;;;;;;;;;;;-1:-1:-1;7696:23:0;;;:281;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;7696:281:0;-1:-1:-1;;;;;7696:281:0;;;;;;;;;;;;;;;;;;;8272:8;8258:37;;8282:12;8258:13;:37::i;:::-;8327:8;;8311:58;;;7982:25:1;;;8038:2;8023:18;;8016:34;;;-1:-1:-1;;;;;8311:58:0;;;8327:8;8311:58;;7955:18:1;8311:58:0;;;;;;;7281:1096;;;;;;;:::o;8418:1202::-;8523:29;8555:22;;;:11;:22;;;;;8653:23;;;:32;;8555:22;;8680:5;;8653:32;;8680:5;;8653:32;:::i;:::-;;;;-1:-1:-1;;9441:23:0;;;;9434:78;;-1:-1:-1;;;9434:78:0;;9479:10;9434:78;;;9803:34:1;9499:4:0;9853:18:1;;;9846:43;9905:18;;;9898:34;;;-1:-1:-1;;;;;9441:23:0;;;;9434:44;;9738:18:1;;9434:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9426:112;;;;-1:-1:-1;;;9426:112:0;;10145:2:1;9426:112:0;;;10127:21:1;10184:2;10164:18;;;10157:30;-1:-1:-1;;;10203:18:1;;;10196:51;10264:18;;9426:112:0;9943:345:1;9426:112:0;9581:23;;;;9554:58;;597:25:1;;;-1:-1:-1;;;;;9581:23:0;;;;9570:9;;9554:58;;585:2:1;570:18;9554:58:0;;;;;;;8476:1144;8418:1202;;:::o;9886:2014::-;10119:10;-1:-1:-1;;;;;10119:25:0;;;10111:74;;;;-1:-1:-1;;;10111:74:0;;10495:2:1;10111:74:0;;;10477:21:1;10534:2;10514:18;;;10507:30;10573:34;10553:18;;;10546:62;-1:-1:-1;;;10624:18:1;;;10617:34;10668:19;;10111:74:0;10293:400:1;10111:74:0;-1:-1:-1;;;;;10242:24:0;;;;;;:11;:24;;;;;;;;:37;;;;;;;;;;;10241:38;10233:70;;;;-1:-1:-1;;;10233:70:0;;10900:2:1;10233:70:0;;;10882:21:1;10939:2;10919:18;;;10912:30;-1:-1:-1;;;10958:18:1;;;10951:49;11017:18;;10233:70:0;10698:343:1;10233:70:0;10403:59;;;-1:-1:-1;;;;;11266:32:1;;10403:59:0;;;11248:51:1;11315:18;;;11308:34;;;11358:18;;;11351:34;;;10378:12:0;;11221:18:1;;10403:59:0;;;-1:-1:-1;;10403:59:0;;;;;;;;;10393:70;;10403:59;10393:70;;;;10516:22;10541:24;;;:11;:24;;;;;;;10516:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;10516:49:0;;;;;;;;;;;;;;10663:40;;-1:-1:-1;;;10663:40:0;;10393:70;;-1:-1:-1;10663:27:0;;;;:40;;10516:49;;10393:70;;10697:5;;10663:40;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10655:85;;;;-1:-1:-1;;;10655:85:0;;12386:2:1;10655:85:0;;;12368:21:1;;;12405:18;;;12398:30;12464:34;12444:18;;;12437:62;12516:18;;10655:85:0;12184:356:1;10655:85:0;-1:-1:-1;;;;;10840:24:0;;;;;;10880:4;10840:24;;;;;;;;:37;;;;;;;;:44;;-1:-1:-1;;10840:44:0;;;;;;:24;;;10966:83;10865:11;11001;11014:16;11032;10966:21;:83::i;:::-;10897:152;;;;;;;;11068:5;11060:42;;;;-1:-1:-1;;;11060:42:0;;12747:2:1;11060:42:0;;;12729:21:1;12786:2;12766:18;;;12759:30;12825:26;12805:18;;;12798:54;12869:18;;11060:42:0;12545:348:1;11060:42:0;11337:510;;;;;;;;11359:10;11337:510;;;;11436:10;11337:510;;;;11483:9;11337:510;;;;11590:11;11572:15;:29;;;;:::i;:::-;11337:510;;;;11660:14;11337:510;;;;11729:9;11337:510;;;11300:8;:21;11309:11;-1:-1:-1;;;;;11300:21:0;-1:-1:-1;;;;;11300:21:0;;;;;;;;;;;;:34;11322:11;11300:34;;;;;;;;;;;:547;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11858:34;11867:11;11880;11858:8;:34::i;:::-;10042:1858;;;;;;9886:2014;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;373:9;360:23;350:33;;402:38;436:2;425:9;421:18;402:38;:::i;:::-;392:48;;192:254;;;;;:::o;633:385::-;719:6;727;735;743;796:3;784:9;775:7;771:23;767:33;764:53;;;813:1;810;803:12;764:53;-1:-1:-1;;836:23:1;;;906:2;891:18;;878:32;;-1:-1:-1;957:2:1;942:18;;929:32;;1008:2;993:18;980:32;;-1:-1:-1;633:385:1;-1:-1:-1;633:385:1:o;1429:180::-;1488:6;1541:2;1529:9;1520:7;1516:23;1512:32;1509:52;;;1557:1;1554;1547:12;1509:52;-1:-1:-1;1580:23:1;;1429:180;-1:-1:-1;1429:180:1:o;2252:254::-;2320:6;2328;2381:2;2369:9;2360:7;2356:23;2352:32;2349:52;;;2397:1;2394;2387:12;2349:52;2420:29;2439:9;2420:29;:::i;:::-;2410:39;2496:2;2481:18;;;;2468:32;;-1:-1:-1;;;2252:254:1:o;3243:598::-;3356:6;3364;3372;3380;3388;3396;3404;3457:3;3445:9;3436:7;3432:23;3428:33;3425:53;;;3474:1;3471;3464:12;3425:53;3510:9;3497:23;3487:33;;3567:2;3556:9;3552:18;3539:32;3529:42;;3618:2;3607:9;3603:18;3590:32;3580:42;;3669:2;3658:9;3654:18;3641:32;3631:42;;3720:3;3709:9;3705:19;3692:33;3682:43;;3744:39;3778:3;3767:9;3763:19;3744:39;:::i;:::-;3734:49;;3830:3;3819:9;3815:19;3802:33;3792:43;;3243:598;;;;;;;;;;:::o;3846:248::-;3914:6;3922;3975:2;3963:9;3954:7;3950:23;3946:32;3943:52;;;3991:1;3988;3981:12;3943:52;-1:-1:-1;;4014:23:1;;;4084:2;4069:18;;;4056:32;;-1:-1:-1;3846:248:1:o;4099:127::-;4160:10;4155:3;4151:20;4148:1;4141:31;4191:4;4188:1;4181:15;4215:4;4212:1;4205:15;4231:1464;4360:6;4368;4376;4384;4392;4400;4453:3;4441:9;4432:7;4428:23;4424:33;4421:53;;;4470:1;4467;4460:12;4421:53;4506:9;4493:23;4483:33;;4535:2;4556:38;4590:2;4579:9;4575:18;4556:38;:::i;:::-;4546:48;;4641:2;4630:9;4626:18;4613:32;4603:42;;4692:2;4681:9;4677:18;4664:32;4654:42;;4743:3;4732:9;4728:19;4715:33;4705:43;;4799:3;4788:9;4784:19;4771:33;4823:18;4864:2;4856:6;4853:14;4850:34;;;4880:1;4877;4870:12;4850:34;4918:6;4907:9;4903:22;4893:32;;4963:7;4956:4;4952:2;4948:13;4944:27;4934:55;;4985:1;4982;4975:12;4934:55;5021:2;5008:16;5043:2;5039;5036:10;5033:36;;;5049:18;;:::i;:::-;5095:2;5092:1;5088:10;5127:2;5121:9;5190:2;5186:7;5181:2;5177;5173:11;5169:25;5161:6;5157:38;5245:6;5233:10;5230:22;5225:2;5213:10;5210:18;5207:46;5204:72;;;5256:18;;:::i;:::-;5292:2;5285:22;5342:18;;;5376:15;;;;-1:-1:-1;5418:11:1;;;5414:20;;;5446:19;;;5443:39;;;5478:1;5475;5468:12;5443:39;5502:11;;;;5522:142;5538:6;5533:3;5530:15;5522:142;;;5604:17;;5592:30;;5555:12;;;;5642;;;;5522:142;;;5683:6;5673:16;;;;;;;;4231:1464;;;;;;;;:::o;6462:127::-;6523:10;6518:3;6514:20;6511:1;6504:31;6554:4;6551:1;6544:15;6578:4;6575:1;6568:15;6594:125;6634:4;6662:1;6659;6656:8;6653:34;;;6667:18;;:::i;:::-;-1:-1:-1;6704:9:1;;6594:125::o;6724:168::-;6764:7;6830:1;6826;6822:6;6818:14;6815:1;6812:21;6807:1;6800:9;6793:17;6789:45;6786:71;;;6837:18;;:::i;:::-;-1:-1:-1;6877:9:1;;6724:168::o;7176:277::-;7243:6;7296:2;7284:9;7275:7;7271:23;7267:32;7264:52;;;7312:1;7309;7302:12;7264:52;7344:9;7338:16;7397:5;7390:13;7383:21;7376:5;7373:32;7363:60;;7419:1;7416;7409:12;7363:60;7442:5;7176:277;-1:-1:-1;;;7176:277:1:o;8061:217::-;8101:1;8127;8117:132;;8171:10;8166:3;8162:20;8159:1;8152:31;8206:4;8203:1;8196:15;8234:4;8231:1;8224:15;8117:132;-1:-1:-1;8263:9:1;;8061:217::o;8283:128::-;8323:3;8354:1;8350:6;8347:1;8344:13;8341:39;;;8360:18;;:::i;:::-;-1:-1:-1;8396:9:1;;8283:128::o;9170:135::-;9209:3;-1:-1:-1;;9230:17:1;;9227:43;;;9250:18;;:::i;:::-;-1:-1:-1;9297:1:1;9286:13;;9170:135::o;11396:783::-;11602:4;11650:2;11639:9;11635:18;11680:6;11669:9;11662:25;11706:2;11744:6;11739:2;11728:9;11724:18;11717:34;11787:2;11782;11771:9;11767:18;11760:30;11810:6;11845;11839:13;11876:6;11868;11861:22;11914:3;11903:9;11899:19;11892:26;;11953:2;11945:6;11941:15;11927:29;;11974:1;11984:169;11998:6;11995:1;11992:13;11984:169;;;12059:13;;12047:26;;12128:15;;;;12093:12;;;;12020:1;12013:9;11984:169;;;-1:-1:-1;12170:3:1;;11396:783;-1:-1:-1;;;;;;;;11396:783:1:o

ipfs://687cdc8caf4759b312e18c50f8c293a8cd99dd62cbf7a80817e3194be09a1507