Contract 0xb789711a8cf2a3938779d01866a4c376598b9fe6 2

/**
 *Submitted for verification at polygonscan.com on 2022-04-22
*/

// Sources flattened with hardhat v2.6.4 https://hardhat.org

// File @openzeppelin/contracts/cryptography/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev These functions deal with verification of Merkle trees (hash trees),
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}


// File @animoca/ethereum-contracts-assets/contracts/token/ERC20/[email protected]

pragma solidity >=0.7.6 <0.8.0;

/**
 * @title ERC20 Token Standard, basic interface
 * @dev See https://eips.ethereum.org/EIPS/eip-20
 * Note: The ERC-165 identifier for this interface is 0x36372b07.
 */
interface IERC20 {
    /**
     * @dev Emitted when tokens are transferred, including zero value transfers.
     * @param _from The account where the transferred tokens are withdrawn from.
     * @param _to The account where the transferred tokens are deposited to.
     * @param _value The amount of tokens being transferred.
     */
    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    /**
     * @dev Emitted when a successful call to {IERC20-approve(address,uint256)} is made.
     * @param _owner The account granting an allowance to `_spender`.
     * @param _spender The account being granted an allowance from `_owner`.
     * @param _value The allowance amount being granted.
     */
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    /**
     * @notice Returns the total token supply.
     * @return The total token supply.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @notice Returns the account balance of another account with address `owner`.
     * @param owner The account whose balance will be returned.
     * @return The account balance of another account with address `owner`.
     */
    function balanceOf(address owner) external view returns (uint256);

    /**
     * Transfers `value` amount of tokens to address `to`.
     * @dev Reverts if `to` is the zero address.
     * @dev Reverts if the sender does not have enough balance.
     * @dev Emits an {IERC20-Transfer} event.
     * @dev Transfers of 0 values are treated as normal transfers and fire the {IERC20-Transfer} event.
     * @param to The receiver account.
     * @param value The amount of tokens to transfer.
     * @return True if the transfer succeeds, false otherwise.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @notice Transfers `value` amount of tokens from address `from` to address `to` via the approval mechanism.
     * @dev Reverts if `to` is the zero address.
     * @dev Reverts if the sender is not `from` and has not been approved by `from` for at least `value`.
     * @dev Reverts if `from` does not have at least `value` of balance.
     * @dev Emits an {IERC20-Transfer} event.
     * @dev Transfers of 0 values are treated as normal transfers and fire the {IERC20-Transfer} event.
     * @param from The emitter account.
     * @param to The receiver account.
     * @param value The amount of tokens to transfer.
     * @return True if the transfer succeeds, false otherwise.
     */
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    /**
     * Sets `value` as the allowance from the caller to `spender`.
     *  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
     * @dev Reverts if `spender` is the zero address.
     * @dev Emits the {IERC20-Approval} event.
     * @param spender The account being granted the allowance by the message caller.
     * @param value The allowance amount to grant.
     * @return True if the approval succeeds, false otherwise.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * Returns the amount which `spender` is allowed to spend on behalf of `owner`.
     * @param owner The account that has granted an allowance to `spender`.
     * @param spender The account that was granted an allowance by `owner`.
     * @return The amount which `spender` is allowed to spend on behalf of `owner`.
     */
    function allowance(address owner, address spender) external view returns (uint256);
}


// File @animoca/ethereum-contracts-core/contracts/metatx/[email protected]

pragma solidity >=0.7.6 <0.8.0;

/*
 * 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.
 */
abstract contract ManagedIdentity {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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


// File @animoca/ethereum-contracts-core/contracts/access/[email protected]

pragma solidity >=0.7.6 <0.8.0;

/**
 * @title ERC-173 Contract Ownership Standard
 * Note: the ERC-165 identifier for this interface is 0x7f5828d0
 */
interface IERC173 {
    /**
     * Event emited when ownership of a contract changes.
     * @param previousOwner the previous owner.
     * @param newOwner the new owner.
     */
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * Get the address of the owner
     * @return The address of the owner.
     */
    function owner() external view returns (address);

    /**
     * Set the address of the new owner of the contract
     * Set newOwner to address(0) to renounce any ownership.
     * @dev Emits an {OwnershipTransferred} event.
     * @param newOwner The address of the new owner of the contract. Using the zero address means renouncing ownership.
     */
    function transferOwnership(address newOwner) external;
}


// File @animoca/ethereum-contracts-core/contracts/access/[email protected]

pragma solidity >=0.7.6 <0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is ManagedIdentity, IERC173 {
    address internal _owner;

    /**
     * Initializes the contract, setting the deployer as the initial owner.
     * @dev Emits an {IERC173-OwnershipTransferred(address,address)} event.
     */
    constructor(address owner_) {
        _owner = owner_;
        emit OwnershipTransferred(address(0), owner_);
    }

    /**
     * Gets the address of the current contract owner.
     */
    function owner() public view virtual override returns (address) {
        return _owner;
    }

    /**
     * See {IERC173-transferOwnership(address)}
     * @dev Reverts if the sender is not the current contract owner.
     * @param newOwner the address of the new owner. Use the zero address to renounce the ownership.
     */
    function transferOwnership(address newOwner) public virtual override {
        _requireOwnership(_msgSender());
        _owner = newOwner;
        emit OwnershipTransferred(_owner, newOwner);
    }

    /**
     * @dev Reverts if `account` is not the contract owner.
     * @param account the account to test.
     */
    function _requireOwnership(address account) internal virtual {
        require(account == this.owner(), "Ownable: not the owner");
    }
}


// File @animoca/ethereum-contracts-core/contracts/utils/types/[email protected]

// Partially derived from OpenZeppelin:
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/406c83649bd6169fc1b578e08506d78f0873b276/contracts/utils/Address.sol

pragma solidity >=0.7.6 <0.8.0;

/**
 * @dev Upgrades the address type to check if it is a contract.
 */
library AddressIsContract {
    /**
     * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }
}


// File @animoca/ethereum-contracts-core/contracts/utils/[email protected]

pragma solidity >=0.7.6 <0.8.0;

/**
 * @title ERC20Wrapper
 * Wraps ERC20 functions to support non-standard implementations which do not return a bool value.
 * Calls to the wrapped functions revert only if they throw or if they return false.
 */
library ERC20Wrapper {
    using AddressIsContract for address;

    function wrappedTransfer(
        IWrappedERC20 token,
        address to,
        uint256 value
    ) internal {
        _callWithOptionalReturnData(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function wrappedTransferFrom(
        IWrappedERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callWithOptionalReturnData(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function wrappedApprove(
        IWrappedERC20 token,
        address spender,
        uint256 value
    ) internal {
        _callWithOptionalReturnData(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function _callWithOptionalReturnData(IWrappedERC20 token, bytes memory callData) internal {
        address target = address(token);
        require(target.isContract(), "ERC20Wrapper: non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory data) = target.call(callData);
        if (success) {
            if (data.length != 0) {
                require(abi.decode(data, (bool)), "ERC20Wrapper: operation failed");
            }
        } else {
            // revert using a standard revert message
            if (data.length == 0) {
                revert("ERC20Wrapper: operation failed");
            }

            // revert using the revert message coming from the call
            assembly {
                let size := mload(data)
                revert(add(32, data), size)
            }
        }
    }
}

interface IWrappedERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);
}


// File contracts/payout/PayoutClaimDistributor.sol
pragma solidity >=0.7.6 <0.8.0;




/// @title PayoutClaimDistributor
contract PayoutClaimDistributor is Ownable {
    using MerkleProof for bytes32[];
    using ERC20Wrapper for IWrappedERC20;

    event SetMerkleRoot(bytes32 indexed merkleRoot);
    event ClaimedPayout(address indexed account, uint256 amount, uint256 salt);
    event DistributionLocked(bool isLocked);
    event SetDistributorAddress(address indexed ownerAddress, address indexed distAddress);

    bytes32 public merkleRoot;
    IWrappedERC20 public token;
    address public distAddress;
    bool public isLocked;

    /*
     * Mapping for hash for (index,  address, amount, salt) for claimed status
     */
    mapping(bytes32 => bool) public claimed;

    /// @dev Constructor for setting ERC token address on deployment
    /// @param token_ Address for token to distribute
    /// @dev `distAddress` deployer address will be distributor address by default
    constructor(IWrappedERC20 token_) Ownable(msg.sender) {
        token = token_;
        distAddress = msg.sender;
    }

    /// @notice Merkle Root for current period to use for payout
    /// @dev Owner sets merkle hash generated based on the payout set
    /// @param merkleRoot_ bytes32 string of merkle root to set for specific period
    function setMerkleRoot(bytes32 merkleRoot_) public {
        _requireOwnership(_msgSender());
        merkleRoot = merkleRoot_;
        emit SetMerkleRoot(merkleRoot_);
    }

    /// @notice Set locked/unlocked status  for PayoutClaim Distributor
    /// @dev Owner lock/unlock each time new merkle root is being generated
    /// @param isLocked_ = true/false status
    function setLocked(bool isLocked_) public {
        _requireOwnership(_msgSender());
        isLocked = isLocked_;
        emit DistributionLocked(isLocked_);
    }

    /// @notice Distributor address in PayoutClaim Distributor
    /// @dev Wallet that holds token for distribution
    /// @param distributorAddress Distributor address used for distribution of `token` token
    function setDistributorAddress(address distributorAddress) public {
        _requireOwnership(_msgSender());
        distAddress = distributorAddress;
        emit SetDistributorAddress(_msgSender(), distributorAddress);
    }

    /// @notice Payout method that user calls to claim
    /// @dev Method user calls for claiming the payout for user
    /// @param account Address of the user to claim the payout
    /// @param amount Claimable amount of address
    /// @param salt Unique value for user for each new merkle root generating
    /// @param merkleProof Merkle proof of the user based on the merkle root
    function claimPayout(
        address account,
        uint256 amount,
        uint256 salt,
        bytes32[] calldata merkleProof
    ) external {
        require(!isLocked, "Payout locked");

        bytes32 leafHash = keccak256(abi.encodePacked(account, amount, salt));

        require(!claimed[leafHash], "Payout already claimed");
        require(merkleProof.verify(merkleRoot, leafHash), "Invalid proof");

        claimed[leafHash] = true;

        token.wrappedTransferFrom(distAddress, account, amount);

        emit ClaimedPayout(account, amount, salt);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IWrappedERC20","name":"token_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"salt","type":"uint256"}],"name":"ClaimedPayout","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isLocked","type":"bool"}],"name":"DistributionLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"ownerAddress","type":"address"},{"indexed":true,"internalType":"address","name":"distAddress","type":"address"}],"name":"SetDistributorAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"SetMerkleRoot","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claimPayout","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"claimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isLocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"distributorAddress","type":"address"}],"name":"setDistributorAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"isLocked_","type":"bool"}],"name":"setLocked","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IWrappedERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000002bc07124d8dac638e290f401046ad584546bc47b

-----Decoded View---------------
Arg [0] : token_ (address): 0x2bc07124d8dac638e290f401046ad584546bc47b

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000002bc07124d8dac638e290f401046ad584546bc47b

13342:3237:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14966:168;;;;;;;;;;;;;;;;-1:-1:-1;14966:168:0;;;;:::i;:::-;;15986:590;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15986:590:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15986:590:0;;-1:-1:-1;15986:590:0;-1:-1:-1;15986:590:0;:::i;13751:25::-;;;:::i;:::-;;;;;;;;;;;;;;;;14584:178;;;;;;;;;;;;;;;;-1:-1:-1;14584:178:0;;:::i;13816:26::-;;;:::i;:::-;;;;-1:-1:-1;;;;;13816:26:0;;;;;;;;;;;;;;15355:230;;;;;;;;;;;;;;;;-1:-1:-1;15355:230:0;-1:-1:-1;;;;;15355:230:0;;:::i;8609:96::-;;;:::i;13849:20::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;13975:39;;;;;;;;;;;;;;;;-1:-1:-1;13975:39:0;;:::i;8952:201::-;;;;;;;;;;;;;;;;-1:-1:-1;8952:201:0;-1:-1:-1;;;;;8952:201:0;;:::i;13783:26::-;;;:::i;14966:168::-;15019:31;15037:12;:10;:12::i;:::-;15019:17;:31::i;:::-;15061:8;:20;;;;;;;;;;;;;;;;;;;15097:29;;;;;;;;;;;;;;;;14966:168;:::o;15986:590::-;16158:8;;;;;;;16157:9;16149:35;;;;;-1:-1:-1;;;16149:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16226:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16216:50;;;;;;;;;16197:16;16288:17;;;:7;:17;;;;;;;;;16287:18;16279:53;;;;;-1:-1:-1;;;16279:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16351:40;16370:10;;16382:8;16351:11;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16351:18:0;;:40;;-1:-1:-1;;16351:18:0;:40;-1:-1:-1;16351:40:0:i;:::-;16343:66;;;;;-1:-1:-1;;;16343:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16422:17;;;;:7;:17;;;;;:24;;;;16442:4;16422:24;;;16485:11;;16459:5;;:55;;-1:-1:-1;;;;;16459:5:0;;;;16485:11;16498:7;16507:6;16459:25;:55::i;:::-;16532:36;;;;;;;;;;;;;;-1:-1:-1;;;;;16532:36:0;;;;;;;;;;;15986:590;;;;;;:::o;13751:25::-;;;;:::o;14584:178::-;14646:31;14664:12;:10;:12::i;14646:31::-;14688:10;:24;;;14728:26;;14701:11;;14728:26;;;;;14584:178;:::o;13816:26::-;;;-1:-1:-1;;;;;13816:26:0;;:::o;15355:230::-;15432:31;15450:12;:10;:12::i;15432:31::-;15474:11;:32;;;;-1:-1:-1;;;;;15474:32:0;;;;;;;;15544:12;:10;:12::i;:::-;-1:-1:-1;;;;;15522:55:0;;;;;;;;;;;15355:230;:::o;8609:96::-;8664:7;8691:6;-1:-1:-1;;;;;8691:6:0;8609:96;:::o;13849:20::-;;;;;;;;;:::o;13975:39::-;;;;;;;;;;;;;;;:::o;8952:201::-;9032:31;9050:12;:10;:12::i;9032:31::-;9074:6;:17;;;;-1:-1:-1;;;;;9074:17:0;;;;;;;;;9107:38;;9074:17;;9128:6;;;9107:38;;9074:6;9107:38;8952:201;:::o;13783:26::-;;;-1:-1:-1;;;;;13783:26:0;;:::o;6251:106::-;6339:10;6251:106;:::o;9284:138::-;9375:4;-1:-1:-1;;;;;9375:10:0;;:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9375:12:0;-1:-1:-1;;;;;9364:23:0;;;;;;9356:58;;;;;-1:-1:-1;;;9356:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9284:138;:::o;654:796::-;745:4;785;745;802:525;826:5;:12;822:1;:16;802:525;;;860:20;883:5;889:1;883:8;;;;;;;;;;;;;;860:31;;928:12;912;:28;908:408;;1082:12;1096;1065:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1055:55;;;;;;1040:70;;908:408;;;1272:12;1286;1255:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1245:55;;;;;;1230:70;;908:408;-1:-1:-1;840:3:0;;802:525;;;-1:-1:-1;1422:20:0;;;;654:796;-1:-1:-1;;;654:796:0:o;11476:266::-;11665:68;;;-1:-1:-1;;;;;11665:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11688:27;11665:68;;;11630:104;;11658:5;;11630:27;:104::i;:::-;11476:266;;;;:::o;11995:892::-;12121:5;12146:19;-1:-1:-1;;;;;12146:17:0;;;:19::i;:::-;12138:58;;;;;-1:-1:-1;;;12138:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12270:12;12284:17;12305:6;-1:-1:-1;;;;;12305:11:0;12317:8;12305:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12269:57;;;;12341:7;12337:543;;;12369:11;;:16;12365:124;;12425:4;12414:24;;;;;;;;;;;;;;;-1:-1:-1;12414:24:0;12406:67;;;;;-1:-1:-1;;;12406:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12337:543;;;12580:11;;12576:97;;12617:40;;;-1:-1:-1;;;12617:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;12576:97;12804:4;12798:11;12849:4;12842;12838:2;12834:13;12827:27;12767:102;11995:892;;;;;:::o;10432:387::-;10755:20;10803:8;;;10432:387::o

ipfs://5aaf2ccbc66cfb7298e25a30ffce2aa1adada272b076e71aa760ea2b7cfd9706