Contract 0x3c27dd05de5159899f854fb3ee97b79e779f409e 2

/**
 *Submitted for verification at polygonscan.com on 2023-03-10
*/

/**
 *Submitted for verification at polygonscan.com on 2023-02-06
*/

/**
 *Submitted for verification at polygonscan.com on 2023-02-06
*/

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


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

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}


/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}



/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}





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

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

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

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}




/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned. The distribution of shares is set at the
 * time of contract deployment and can't be updated thereafter.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    ///////////////// START modified for large group of payees ///////////////////////
    address public tempAdmin;

    /**
     * @dev Creates an instance of `PaymentSplitter`
     * Set temp admin
     */
    constructor() payable {
        tempAdmin = msg.sender;
    }

    function dropTempAdmin() external {
        require(msg.sender == tempAdmin, "PaymentSplitter: only temp admin");
        tempAdmin = address(0);
    }

    /**
     * @dev Each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    function addPayees(address[] calldata payees, uint256[] calldata shares_) external {
        require(msg.sender == tempAdmin, "PaymentSplitter: only temp admin");
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        uint256 payeesLength = payees.length;
        for (uint256 i = 0; i < payeesLength; ++i) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    ///////////////// END modified for large group of payees ///////////////////////

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Getter for the amount of payee's releasable Ether.
     */
    function releasable(address account) public view returns (uint256) {
        uint256 totalReceived = address(this).balance + totalReleased();
        return _pendingPayment(account, totalReceived, released(account));
    }

    /**
     * @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
     * IERC20 contract.
     */
    function releasable(IERC20 token, address account) public view returns (uint256) {
        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        return _pendingPayment(account, totalReceived, released(token, account));
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // _totalReleased is the sum of all values in _released.
        // If "_totalReleased += payment" does not overflow, then "_released[account] += payment" cannot overflow.
        _totalReleased += payment;
        unchecked {
            _released[account] += payment;
        }

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(token, account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // _erc20TotalReleased[token] is the sum of all values in _erc20Released[token].
        // If "_erc20TotalReleased[token] += payment" does not overflow, then "_erc20Released[token][account] += payment"
        // cannot overflow.
        _erc20TotalReleased[token] += payment;
        unchecked {
            _erc20Released[token][account] += payment;
        }

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","type":"event"},{"inputs":[{"internalType":"address[]","name":"payees","type":"address[]"},{"internalType":"uint256[]","name":"shares_","type":"uint256[]"}],"name":"addPayees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dropTempAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tempAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

20760:7913:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23327:40;23343:12;:10;:12::i;:::-;23357:9;23327:40;;;;;;;:::i;:::-;;;;;;;;20760:7913;;;;;25848:671;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;23458:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24587:135;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21694:154;;;;;;;;;;;;;:::i;:::-;;26787:792;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22162:503;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;24813:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24309:109;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25003:225;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21495:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25388:260;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24105:105;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23895:119;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23643:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;804:98;857:7;884:10;877:17;;804:98;:::o;25848:671::-;25943:1;25924:7;:16;25932:7;25924:16;;;;;;;;;;;;;;;;:20;25916:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;26000:15;26018:19;26029:7;26018:10;:19::i;:::-;26000:37;;26069:1;26058:7;:12;26050:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26331:7;26313:14;;:25;;;;;;;:::i;:::-;;;;;;;;26396:7;26374:9;:18;26384:7;26374:18;;;;;;;;;;;;;;;;:29;;;;;;;;;;;26427:35;26445:7;26454;26427:17;:35::i;:::-;26478:33;26494:7;26503;26478:33;;;;;;;:::i;:::-;;;;;;;;25905:614;25848:671;:::o;23458:91::-;23502:7;23529:12;;23522:19;;23458:91;:::o;24587:135::-;24657:7;24684:14;:21;24699:5;24684:21;;;;;;;;;;;;;;;:30;24706:7;24684:30;;;;;;;;;;;;;;;;24677:37;;24587:135;;;;:::o;21694:154::-;21761:9;;;;;;;;;;;21747:23;;:10;:23;;;21739:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;21838:1;21818:9;;:22;;;;;;;;;;;;;;;;;;21694:154::o;26787:792::-;26888:1;26869:7;:16;26877:7;26869:16;;;;;;;;;;;;;;;;:20;26861:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;26945:15;26963:26;26974:5;26981:7;26963:10;:26::i;:::-;26945:44;;27021:1;27010:7;:12;27002:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;27355:7;27325:19;:26;27345:5;27325:26;;;;;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;27432:7;27398:14;:21;27413:5;27398:21;;;;;;;;;;;;;;;:30;27420:7;27398:30;;;;;;;;;;;;;;;;:41;;;;;;;;;;;27463:47;27486:5;27493:7;27502;27463:22;:47::i;:::-;27547:5;27526:45;;;27554:7;27563;27526:45;;;;;;;:::i;:::-;;;;;;;;26850:729;26787:792;;:::o;22162:503::-;22278:9;;;;;;;;;;;22264:23;;:10;:23;;;22256:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;22360:7;;:14;;22343:6;;:13;;:31;22335:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;22464:1;22448:6;;:13;;:17;22440:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;22509:20;22532:6;;:13;;22509:36;;22561:9;22556:102;22580:12;22576:1;:16;22556:102;;;22614:32;22624:6;;22631:1;22624:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;22635:7;;22643:1;22635:10;;;;;;;:::i;:::-;;;;;;;;22614:9;:32::i;:::-;22594:3;;;;:::i;:::-;;;22556:102;;;;22245:420;22162:503;;;;:::o;24813:100::-;24864:7;24891;24899:5;24891:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;24884:21;;24813:100;;;:::o;24309:109::-;24365:7;24392:9;:18;24402:7;24392:18;;;;;;;;;;;;;;;;24385:25;;24309:109;;;:::o;25003:225::-;25061:7;25081:21;25129:15;:13;:15::i;:::-;25105:21;:39;;;;:::i;:::-;25081:63;;25162:58;25178:7;25187:13;25202:17;25211:7;25202:8;:17::i;:::-;25162:15;:58::i;:::-;25155:65;;;25003:225;;;:::o;21495:24::-;;;;;;;;;;;;;:::o;25388:260::-;25460:7;25480:21;25537:20;25551:5;25537:13;:20::i;:::-;25504:5;:15;;;25528:4;25504:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;25480:77;;25575:65;25591:7;25600:13;25615:24;25624:5;25631:7;25615:8;:24::i;:::-;25575:15;:65::i;:::-;25568:72;;;25388:260;;;;:::o;24105:105::-;24159:7;24186;:16;24194:7;24186:16;;;;;;;;;;;;;;;;24179:23;;24105:105;;;:::o;23895:119::-;23953:7;23980:19;:26;24000:5;23980:26;;;;;;;;;;;;;;;;23973:33;;23895:119;;;:::o;23643:95::-;23689:7;23716:14;;23709:21;;23643:95;:::o;6077:317::-;6192:6;6167:21;:31;;6159:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;6246:12;6264:9;:14;;6286:6;6264:33;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6245:52;;;6316:7;6308:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;6148:246;6077:317;;:::o;15719:211::-;15836:86;15856:5;15886:23;;;15911:2;15915:5;15863:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15836:19;:86::i;:::-;15719:211;;;:::o;28197:473::-;28296:1;28277:21;;:7;:21;;;28269:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;28376:1;28366:7;:11;28358:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;28450:1;28430:7;:16;28438:7;28430:16;;;;;;;;;;;;;;;;:21;28422:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;28512:7;28525;28512:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28563:7;28544;:16;28552:7;28544:16;;;;;;;;;;;;;;;:26;;;;28611:7;28596:12;;:22;;;;:::i;:::-;28581:12;:37;;;;28634:28;28645:7;28654;28634:28;;;;;;;:::i;:::-;;;;;;;;28197:473;;:::o;27757:248::-;27903:7;27982:15;27967:12;;27947:7;:16;27955:7;27947:16;;;;;;;;;;;;;;;;27931:13;:32;;;;:::i;:::-;27930:49;;;;:::i;:::-;:67;;;;:::i;:::-;27923:74;;27757:248;;;;;:::o;18786:716::-;19210:23;19236:69;19264:4;19236:69;;;;;;;;;;;;;;;;;19244:5;19236:27;;;;:69;;;;;:::i;:::-;19210:95;;19340:1;19320:10;:17;:21;19316:179;;;19417:10;19406:30;;;;;;;;;;;;:::i;:::-;19398:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;19316:179;18856:646;18786:716;;:::o;7573:229::-;7710:12;7742:52;7764:6;7772:4;7778:1;7781:12;7742:21;:52::i;:::-;7735:59;;7573:229;;;;;:::o;8693:455::-;8863:12;8921:5;8896:21;:30;;8888:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;8981:12;8995:23;9022:6;:11;;9041:5;9048:4;9022:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8980:73;;;;9071:69;9098:6;9106:7;9115:10;9127:12;9071:26;:69::i;:::-;9064:76;;;;8693:455;;;;;;:::o;11266:644::-;11451:12;11480:7;11476:427;;;11529:1;11508:10;:17;:22;11504:290;;11726:18;11737:6;11726:10;:18::i;:::-;11718:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;11504:290;11815:10;11808:17;;;;11476:427;11858:33;11866:10;11878:12;11858:7;:33::i;:::-;11266:644;;;;;;;:::o;4816:326::-;4876:4;5133:1;5111:7;:19;;;:23;5104:30;;4816:326;;;:::o;12452:552::-;12633:1;12613:10;:17;:21;12609:388;;;12845:10;12839:17;12902:15;12889:10;12885:2;12881:19;12874:44;12609:388;12972:12;12965:20;;;;;;;;;;;:::i;:::-;;;;;;;;7:126:1;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:77::-;402:7;431:5;420:16;;365:77;;;:::o;448:118::-;535:24;553:5;535:24;:::i;:::-;530:3;523:37;448:118;;:::o;572:332::-;693:4;731:2;720:9;716:18;708:26;;744:71;812:1;801:9;797:17;788:6;744:71;:::i;:::-;825:72;893:2;882:9;878:18;869:6;825:72;:::i;:::-;572:332;;;;;:::o;991:117::-;1100:1;1097;1090:12;1114:117;1223:1;1220;1213:12;1237:104;1282:7;1311:24;1329:5;1311:24;:::i;:::-;1300:35;;1237:104;;;:::o;1347:138::-;1428:32;1454:5;1428:32;:::i;:::-;1421:5;1418:43;1408:71;;1475:1;1472;1465:12;1408:71;1347:138;:::o;1491:155::-;1545:5;1583:6;1570:20;1561:29;;1599:41;1634:5;1599:41;:::i;:::-;1491:155;;;;:::o;1652:345::-;1719:6;1768:2;1756:9;1747:7;1743:23;1739:32;1736:119;;;1774:79;;:::i;:::-;1736:119;1894:1;1919:61;1972:7;1963:6;1952:9;1948:22;1919:61;:::i;:::-;1909:71;;1865:125;1652:345;;;;:::o;2003:222::-;2096:4;2134:2;2123:9;2119:18;2111:26;;2147:71;2215:1;2204:9;2200:17;2191:6;2147:71;:::i;:::-;2003:222;;;;:::o;2231:109::-;2281:7;2310:24;2328:5;2310:24;:::i;:::-;2299:35;;2231:109;;;:::o;2346:148::-;2432:37;2463:5;2432:37;:::i;:::-;2425:5;2422:48;2412:76;;2484:1;2481;2474:12;2412:76;2346:148;:::o;2500:165::-;2559:5;2597:6;2584:20;2575:29;;2613:46;2653:5;2613:46;:::i;:::-;2500:165;;;;:::o;2671:122::-;2744:24;2762:5;2744:24;:::i;:::-;2737:5;2734:35;2724:63;;2783:1;2780;2773:12;2724:63;2671:122;:::o;2799:139::-;2845:5;2883:6;2870:20;2861:29;;2899:33;2926:5;2899:33;:::i;:::-;2799:139;;;;:::o;2944:500::-;3025:6;3033;3082:2;3070:9;3061:7;3057:23;3053:32;3050:119;;;3088:79;;:::i;:::-;3050:119;3208:1;3233:66;3291:7;3282:6;3271:9;3267:22;3233:66;:::i;:::-;3223:76;;3179:130;3348:2;3374:53;3419:7;3410:6;3399:9;3395:22;3374:53;:::i;:::-;3364:63;;3319:118;2944:500;;;;;:::o;3450:117::-;3559:1;3556;3549:12;3573:117;3682:1;3679;3672:12;3696:117;3805:1;3802;3795:12;3836:568;3909:8;3919:6;3969:3;3962:4;3954:6;3950:17;3946:27;3936:122;;3977:79;;:::i;:::-;3936:122;4090:6;4077:20;4067:30;;4120:18;4112:6;4109:30;4106:117;;;4142:79;;:::i;:::-;4106:117;4256:4;4248:6;4244:17;4232:29;;4310:3;4302:4;4294:6;4290:17;4280:8;4276:32;4273:41;4270:128;;;4317:79;;:::i;:::-;4270:128;3836:568;;;;;:::o;4427:::-;4500:8;4510:6;4560:3;4553:4;4545:6;4541:17;4537:27;4527:122;;4568:79;;:::i;:::-;4527:122;4681:6;4668:20;4658:30;;4711:18;4703:6;4700:30;4697:117;;;4733:79;;:::i;:::-;4697:117;4847:4;4839:6;4835:17;4823:29;;4901:3;4893:4;4885:6;4881:17;4871:8;4867:32;4864:41;4861:128;;;4908:79;;:::i;:::-;4861:128;4427:568;;;;;:::o;5001:934::-;5123:6;5131;5139;5147;5196:2;5184:9;5175:7;5171:23;5167:32;5164:119;;;5202:79;;:::i;:::-;5164:119;5350:1;5339:9;5335:17;5322:31;5380:18;5372:6;5369:30;5366:117;;;5402:79;;:::i;:::-;5366:117;5515:80;5587:7;5578:6;5567:9;5563:22;5515:80;:::i;:::-;5497:98;;;;5293:312;5672:2;5661:9;5657:18;5644:32;5703:18;5695:6;5692:30;5689:117;;;5725:79;;:::i;:::-;5689:117;5838:80;5910:7;5901:6;5890:9;5886:22;5838:80;:::i;:::-;5820:98;;;;5615:313;5001:934;;;;;;;:::o;5941:122::-;6014:24;6032:5;6014:24;:::i;:::-;6007:5;6004:35;5994:63;;6053:1;6050;6043:12;5994:63;5941:122;:::o;6069:139::-;6115:5;6153:6;6140:20;6131:29;;6169:33;6196:5;6169:33;:::i;:::-;6069:139;;;;:::o;6214:329::-;6273:6;6322:2;6310:9;6301:7;6297:23;6293:32;6290:119;;;6328:79;;:::i;:::-;6290:119;6448:1;6473:53;6518:7;6509:6;6498:9;6494:22;6473:53;:::i;:::-;6463:63;;6419:117;6214:329;;;;:::o;6549:222::-;6642:4;6680:2;6669:9;6665:18;6657:26;;6693:71;6761:1;6750:9;6746:17;6737:6;6693:71;:::i;:::-;6549:222;;;;:::o;6777:329::-;6836:6;6885:2;6873:9;6864:7;6860:23;6856:32;6853:119;;;6891:79;;:::i;:::-;6853:119;7011:1;7036:53;7081:7;7072:6;7061:9;7057:22;7036:53;:::i;:::-;7026:63;;6982:117;6777:329;;;;:::o;7112:355::-;7184:6;7233:2;7221:9;7212:7;7208:23;7204:32;7201:119;;;7239:79;;:::i;:::-;7201:119;7359:1;7384:66;7442:7;7433:6;7422:9;7418:22;7384:66;:::i;:::-;7374:76;;7330:130;7112:355;;;;:::o;7473:169::-;7557:11;7591:6;7586:3;7579:19;7631:4;7626:3;7622:14;7607:29;;7473:169;;;;:::o;7648:225::-;7788:34;7784:1;7776:6;7772:14;7765:58;7857:8;7852:2;7844:6;7840:15;7833:33;7648:225;:::o;7879:366::-;8021:3;8042:67;8106:2;8101:3;8042:67;:::i;:::-;8035:74;;8118:93;8207:3;8118:93;:::i;:::-;8236:2;8231:3;8227:12;8220:19;;7879:366;;;:::o;8251:419::-;8417:4;8455:2;8444:9;8440:18;8432:26;;8504:9;8498:4;8494:20;8490:1;8479:9;8475:17;8468:47;8532:131;8658:4;8532:131;:::i;:::-;8524:139;;8251:419;;;:::o;8676:230::-;8816:34;8812:1;8804:6;8800:14;8793:58;8885:13;8880:2;8872:6;8868:15;8861:38;8676:230;:::o;8912:366::-;9054:3;9075:67;9139:2;9134:3;9075:67;:::i;:::-;9068:74;;9151:93;9240:3;9151:93;:::i;:::-;9269:2;9264:3;9260:12;9253:19;;8912:366;;;:::o;9284:419::-;9450:4;9488:2;9477:9;9473:18;9465:26;;9537:9;9531:4;9527:20;9523:1;9512:9;9508:17;9501:47;9565:131;9691:4;9565:131;:::i;:::-;9557:139;;9284:419;;;:::o;9709:180::-;9757:77;9754:1;9747:88;9854:4;9851:1;9844:15;9878:4;9875:1;9868:15;9895:191;9935:3;9954:20;9972:1;9954:20;:::i;:::-;9949:25;;9988:20;10006:1;9988:20;:::i;:::-;9983:25;;10031:1;10028;10024:9;10017:16;;10052:3;10049:1;10046:10;10043:36;;;10059:18;;:::i;:::-;10043:36;9895:191;;;;:::o;10092:60::-;10120:3;10141:5;10134:12;;10092:60;;;:::o;10158:142::-;10208:9;10241:53;10259:34;10268:24;10286:5;10268:24;:::i;:::-;10259:34;:::i;:::-;10241:53;:::i;:::-;10228:66;;10158:142;;;:::o;10306:126::-;10356:9;10389:37;10420:5;10389:37;:::i;:::-;10376:50;;10306:126;;;:::o;10438:134::-;10496:9;10529:37;10560:5;10529:37;:::i;:::-;10516:50;;10438:134;;;:::o;10578:147::-;10673:45;10712:5;10673:45;:::i;:::-;10668:3;10661:58;10578:147;;:::o;10731:348::-;10860:4;10898:2;10887:9;10883:18;10875:26;;10911:79;10987:1;10976:9;10972:17;10963:6;10911:79;:::i;:::-;11000:72;11068:2;11057:9;11053:18;11044:6;11000:72;:::i;:::-;10731:348;;;;;:::o;11085:182::-;11225:34;11221:1;11213:6;11209:14;11202:58;11085:182;:::o;11273:366::-;11415:3;11436:67;11500:2;11495:3;11436:67;:::i;:::-;11429:74;;11512:93;11601:3;11512:93;:::i;:::-;11630:2;11625:3;11621:12;11614:19;;11273:366;;;:::o;11645:419::-;11811:4;11849:2;11838:9;11834:18;11826:26;;11898:9;11892:4;11888:20;11884:1;11873:9;11869:17;11862:47;11926:131;12052:4;11926:131;:::i;:::-;11918:139;;11645:419;;;:::o;12070:237::-;12210:34;12206:1;12198:6;12194:14;12187:58;12279:20;12274:2;12266:6;12262:15;12255:45;12070:237;:::o;12313:366::-;12455:3;12476:67;12540:2;12535:3;12476:67;:::i;:::-;12469:74;;12552:93;12641:3;12552:93;:::i;:::-;12670:2;12665:3;12661:12;12654:19;;12313:366;;;:::o;12685:419::-;12851:4;12889:2;12878:9;12874:18;12866:26;;12938:9;12932:4;12928:20;12924:1;12913:9;12909:17;12902:47;12966:131;13092:4;12966:131;:::i;:::-;12958:139;;12685:419;;;:::o;13110:176::-;13250:28;13246:1;13238:6;13234:14;13227:52;13110:176;:::o;13292:366::-;13434:3;13455:67;13519:2;13514:3;13455:67;:::i;:::-;13448:74;;13531:93;13620:3;13531:93;:::i;:::-;13649:2;13644:3;13640:12;13633:19;;13292:366;;;:::o;13664:419::-;13830:4;13868:2;13857:9;13853:18;13845:26;;13917:9;13911:4;13907:20;13903:1;13892:9;13888:17;13881:47;13945:131;14071:4;13945:131;:::i;:::-;13937:139;;13664:419;;;:::o;14089:180::-;14137:77;14134:1;14127:88;14234:4;14231:1;14224:15;14258:4;14255:1;14248:15;14275:233;14314:3;14337:24;14355:5;14337:24;:::i;:::-;14328:33;;14383:66;14376:5;14373:77;14370:103;;14453:18;;:::i;:::-;14370:103;14500:1;14493:5;14489:13;14482:20;;14275:233;;;:::o;14514:143::-;14571:5;14602:6;14596:13;14587:22;;14618:33;14645:5;14618:33;:::i;:::-;14514:143;;;;:::o;14663:351::-;14733:6;14782:2;14770:9;14761:7;14757:23;14753:32;14750:119;;;14788:79;;:::i;:::-;14750:119;14908:1;14933:64;14989:7;14980:6;14969:9;14965:22;14933:64;:::i;:::-;14923:74;;14879:128;14663:351;;;;:::o;15020:179::-;15160:31;15156:1;15148:6;15144:14;15137:55;15020:179;:::o;15205:366::-;15347:3;15368:67;15432:2;15427:3;15368:67;:::i;:::-;15361:74;;15444:93;15533:3;15444:93;:::i;:::-;15562:2;15557:3;15553:12;15546:19;;15205:366;;;:::o;15577:419::-;15743:4;15781:2;15770:9;15766:18;15758:26;;15830:9;15824:4;15820:20;15816:1;15805:9;15801:17;15794:47;15858:131;15984:4;15858:131;:::i;:::-;15850:139;;15577:419;;;:::o;16002:147::-;16103:11;16140:3;16125:18;;16002:147;;;;:::o;16155:114::-;;:::o;16275:398::-;16434:3;16455:83;16536:1;16531:3;16455:83;:::i;:::-;16448:90;;16547:93;16636:3;16547:93;:::i;:::-;16665:1;16660:3;16656:11;16649:18;;16275:398;;;:::o;16679:379::-;16863:3;16885:147;17028:3;16885:147;:::i;:::-;16878:154;;17049:3;17042:10;;16679:379;;;:::o;17064:245::-;17204:34;17200:1;17192:6;17188:14;17181:58;17273:28;17268:2;17260:6;17256:15;17249:53;17064:245;:::o;17315:366::-;17457:3;17478:67;17542:2;17537:3;17478:67;:::i;:::-;17471:74;;17554:93;17643:3;17554:93;:::i;:::-;17672:2;17667:3;17663:12;17656:19;;17315:366;;;:::o;17687:419::-;17853:4;17891:2;17880:9;17876:18;17868:26;;17940:9;17934:4;17930:20;17926:1;17915:9;17911:17;17904:47;17968:131;18094:4;17968:131;:::i;:::-;17960:139;;17687:419;;;:::o;18112:231::-;18252:34;18248:1;18240:6;18236:14;18229:58;18321:14;18316:2;18308:6;18304:15;18297:39;18112:231;:::o;18349:366::-;18491:3;18512:67;18576:2;18571:3;18512:67;:::i;:::-;18505:74;;18588:93;18677:3;18588:93;:::i;:::-;18706:2;18701:3;18697:12;18690:19;;18349:366;;;:::o;18721:419::-;18887:4;18925:2;18914:9;18910:18;18902:26;;18974:9;18968:4;18964:20;18960:1;18949:9;18945:17;18938:47;19002:131;19128:4;19002:131;:::i;:::-;18994:139;;18721:419;;;:::o;19146:179::-;19286:31;19282:1;19274:6;19270:14;19263:55;19146:179;:::o;19331:366::-;19473:3;19494:67;19558:2;19553:3;19494:67;:::i;:::-;19487:74;;19570:93;19659:3;19570:93;:::i;:::-;19688:2;19683:3;19679:12;19672:19;;19331:366;;;:::o;19703:419::-;19869:4;19907:2;19896:9;19892:18;19884:26;;19956:9;19950:4;19946:20;19942:1;19931:9;19927:17;19920:47;19984:131;20110:4;19984:131;:::i;:::-;19976:139;;19703:419;;;:::o;20128:230::-;20268:34;20264:1;20256:6;20252:14;20245:58;20337:13;20332:2;20324:6;20320:15;20313:38;20128:230;:::o;20364:366::-;20506:3;20527:67;20591:2;20586:3;20527:67;:::i;:::-;20520:74;;20603:93;20692:3;20603:93;:::i;:::-;20721:2;20716:3;20712:12;20705:19;;20364:366;;;:::o;20736:419::-;20902:4;20940:2;20929:9;20925:18;20917:26;;20989:9;20983:4;20979:20;20975:1;20964:9;20960:17;20953:47;21017:131;21143:4;21017:131;:::i;:::-;21009:139;;20736:419;;;:::o;21161:410::-;21201:7;21224:20;21242:1;21224:20;:::i;:::-;21219:25;;21258:20;21276:1;21258:20;:::i;:::-;21253:25;;21313:1;21310;21306:9;21335:30;21353:11;21335:30;:::i;:::-;21324:41;;21514:1;21505:7;21501:15;21498:1;21495:22;21475:1;21468:9;21448:83;21425:139;;21544:18;;:::i;:::-;21425:139;21209:362;21161:410;;;;:::o;21577:180::-;21625:77;21622:1;21615:88;21722:4;21719:1;21712:15;21746:4;21743:1;21736:15;21763:185;21803:1;21820:20;21838:1;21820:20;:::i;:::-;21815:25;;21854:20;21872:1;21854:20;:::i;:::-;21849:25;;21893:1;21883:35;;21898:18;;:::i;:::-;21883:35;21940:1;21937;21933:9;21928:14;;21763:185;;;;:::o;21954:194::-;21994:4;22014:20;22032:1;22014:20;:::i;:::-;22009:25;;22048:20;22066:1;22048:20;:::i;:::-;22043:25;;22092:1;22089;22085:9;22077:17;;22116:1;22110:4;22107:11;22104:37;;;22121:18;;:::i;:::-;22104:37;21954:194;;;;:::o;22154:90::-;22188:7;22231:5;22224:13;22217:21;22206:32;;22154:90;;;:::o;22250:116::-;22320:21;22335:5;22320:21;:::i;:::-;22313:5;22310:32;22300:60;;22356:1;22353;22346:12;22300:60;22250:116;:::o;22372:137::-;22426:5;22457:6;22451:13;22442:22;;22473:30;22497:5;22473:30;:::i;:::-;22372:137;;;;:::o;22515:345::-;22582:6;22631:2;22619:9;22610:7;22606:23;22602:32;22599:119;;;22637:79;;:::i;:::-;22599:119;22757:1;22782:61;22835:7;22826:6;22815:9;22811:22;22782:61;:::i;:::-;22772:71;;22728:125;22515:345;;;;:::o;22866:229::-;23006:34;23002:1;22994:6;22990:14;22983:58;23075:12;23070:2;23062:6;23058:15;23051:37;22866:229;:::o;23101:366::-;23243:3;23264:67;23328:2;23323:3;23264:67;:::i;:::-;23257:74;;23340:93;23429:3;23340:93;:::i;:::-;23458:2;23453:3;23449:12;23442:19;;23101:366;;;:::o;23473:419::-;23639:4;23677:2;23666:9;23662:18;23654:26;;23726:9;23720:4;23716:20;23712:1;23701:9;23697:17;23690:47;23754:131;23880:4;23754:131;:::i;:::-;23746:139;;23473:419;;;:::o;23898:225::-;24038:34;24034:1;24026:6;24022:14;24015:58;24107:8;24102:2;24094:6;24090:15;24083:33;23898:225;:::o;24129:366::-;24271:3;24292:67;24356:2;24351:3;24292:67;:::i;:::-;24285:74;;24368:93;24457:3;24368:93;:::i;:::-;24486:2;24481:3;24477:12;24470:19;;24129:366;;;:::o;24501:419::-;24667:4;24705:2;24694:9;24690:18;24682:26;;24754:9;24748:4;24744:20;24740:1;24729:9;24725:17;24718:47;24782:131;24908:4;24782:131;:::i;:::-;24774:139;;24501:419;;;:::o;24926:98::-;24977:6;25011:5;25005:12;24995:22;;24926:98;;;:::o;25030:246::-;25111:1;25121:113;25135:6;25132:1;25129:13;25121:113;;;25220:1;25215:3;25211:11;25205:18;25201:1;25196:3;25192:11;25185:39;25157:2;25154:1;25150:10;25145:15;;25121:113;;;25268:1;25259:6;25254:3;25250:16;25243:27;25092:184;25030:246;;;:::o;25282:386::-;25386:3;25414:38;25446:5;25414:38;:::i;:::-;25468:88;25549:6;25544:3;25468:88;:::i;:::-;25461:95;;25565:65;25623:6;25618:3;25611:4;25604:5;25600:16;25565:65;:::i;:::-;25655:6;25650:3;25646:16;25639:23;;25390:278;25282:386;;;;:::o;25674:271::-;25804:3;25826:93;25915:3;25906:6;25826:93;:::i;:::-;25819:100;;25936:3;25929:10;;25674:271;;;;:::o;25951:179::-;26091:31;26087:1;26079:6;26075:14;26068:55;25951:179;:::o;26136:366::-;26278:3;26299:67;26363:2;26358:3;26299:67;:::i;:::-;26292:74;;26375:93;26464:3;26375:93;:::i;:::-;26493:2;26488:3;26484:12;26477:19;;26136:366;;;:::o;26508:419::-;26674:4;26712:2;26701:9;26697:18;26689:26;;26761:9;26755:4;26751:20;26747:1;26736:9;26732:17;26725:47;26789:131;26915:4;26789:131;:::i;:::-;26781:139;;26508:419;;;:::o;26933:99::-;26985:6;27019:5;27013:12;27003:22;;26933:99;;;:::o;27038:102::-;27079:6;27130:2;27126:7;27121:2;27114:5;27110:14;27106:28;27096:38;;27038:102;;;:::o;27146:377::-;27234:3;27262:39;27295:5;27262:39;:::i;:::-;27317:71;27381:6;27376:3;27317:71;:::i;:::-;27310:78;;27397:65;27455:6;27450:3;27443:4;27436:5;27432:16;27397:65;:::i;:::-;27487:29;27509:6;27487:29;:::i;:::-;27482:3;27478:39;27471:46;;27238:285;27146:377;;;;:::o;27529:313::-;27642:4;27680:2;27669:9;27665:18;27657:26;;27729:9;27723:4;27719:20;27715:1;27704:9;27700:17;27693:47;27757:78;27830:4;27821:6;27757:78;:::i;:::-;27749:86;;27529:313;;;;:::o

ipfs://741911793fbf5ecf4777b67cc880b3795813c934d734980ed05dedc14963dee2