Contract 0xd044aCcb05a33660E4Aa7960E76b1dE4fDb60E3A 1

/**
 *Submitted for verification at FtmScan.com on 2023-05-26
*/

/*
 *Token Latin Global Multisender
*/


// File: @openzeppelin/contracts/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;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol



pragma solidity ^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 Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol



pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: @openzeppelin/contracts/utils/math/SafeMath.sol



pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



pragma solidity ^0.8.0;

/**
 * @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);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol



pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol



pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol



pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol



pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol



pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol



pragma solidity ^0.8.0;


/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/token/ERC1155/utils/ERC1155Receiver.sol



pragma solidity ^0.8.0;



/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

// File: @openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol



pragma solidity ^0.8.0;


/**
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// File: a.sol


pragma solidity ^0.8.7;




contract Multisender is ERC1155Holder, ReentrancyGuard, Ownable {

  using SafeMath for uint256;

  address payable public feeReceiver;
  uint256 public ethFee;
  uint256 public array_limit;


  bytes emptyData = bytes("");


  constructor()  {
    ethFee = 0.01 ether;
    feeReceiver =payable(msg.sender);
    array_limit = 200;
  }


    function arrayLimit() public view returns(uint256) {
        return array_limit;
    }

    function currentFee(address _customer) public view returns(uint256) {
        if(_customer == address(0x0)){
            return 0;
        }
        return  ethFee;
    }


  // Internal function to send ERC721 or ERC20 tokens
  // Using transferFrom means we don't implement ERC721 Receiver
  function _send721Or20(address tokenAddress, address from, address to, uint256 amountOrId) internal {
    IERC721(tokenAddress).transferFrom(from, to, amountOrId);
  }



  // Direct senders

  // Normal multisend: sends a batch of ERC721 or ERC20 to a list of addresses
  function multisendToken(
    address tokenAddress,
    address[] calldata userAddresses,
    uint256[] calldata amountsOrIds
   ) external payable nonReentrant {
    require((userAddresses.length == amountsOrIds.length), "diff lengths");
    for (uint256 i = 0; i < userAddresses.length; i++) {
      _send721Or20(tokenAddress, msg.sender, userAddresses[i], amountsOrIds[i]);
    }
  }

// ERC721 targeted multisend: sends a batch of ERC721 or ERC20s to a list of ERC721 ID holders
  function send721Or20To721Ids(
    address[] calldata erc721Addresses,
    uint256[] calldata receiverIds,
    uint256[] calldata amountsOrIds,
    address tokenAddress) external payable nonReentrant {
    require((erc721Addresses.length == receiverIds.length), "diff lengths");
    require((erc721Addresses.length == amountsOrIds.length), "diff lengths");
    for (uint256 i = 0; i < receiverIds.length; i++) {
      IERC721Enumerable erc721 = IERC721Enumerable(erc721Addresses[i]);
      _send721Or20(tokenAddress, msg.sender, erc721.ownerOf(receiverIds[i]), amountsOrIds[i]);
    }
  }

  // Send ERC-1155 to a batch of addresses
  function send1155ToAddresses(
    address[] calldata userAddresses,
    uint256[] calldata tokenIds,
    uint256[] calldata amounts,
    address tokenAddress) external payable nonReentrant {
    require((userAddresses.length == amounts.length), "diff lengths");
    require((userAddresses.length == tokenIds.length), "diff lengths");
    for (uint256 i = 0; i < userAddresses.length; i++) {
      IERC1155(tokenAddress).safeTransferFrom(msg.sender, userAddresses[i], tokenIds[i], amounts[i], emptyData);
    }
  }

  // Send ERC-1155 to a list of ERC721 ID holders
  function send1155To721Ids(
    address[] calldata erc721Addresses,
    uint256[] calldata erc721Ids,
    uint256[] calldata tokenIds,
    uint256[] calldata amounts,
    address tokenAddress) external payable nonReentrant {
    require((erc721Addresses.length == erc721Ids.length), "diff lengths");
    require((erc721Addresses.length == amounts.length), "diff lengths");
    require((erc721Addresses.length == tokenIds.length), "diff lengths");
    for (uint256 i = 0; i < erc721Addresses.length; i++) {
      IERC1155(tokenAddress).safeTransferFrom(msg.sender, IERC721(erc721Addresses[i]).ownerOf(erc721Ids[i]), tokenIds[i], amounts[i], emptyData);
    }
  }





  // OWNER FUNCTIONS

  function setFeeReceiver(address payable a) public onlyOwner {
    feeReceiver = a;
  }

  function setEthFee(uint256 f) public onlyOwner {
    ethFee = f;
  }
  
    function claimTokens(address _token) public onlyOwner {
        if (_token == address(0x0)) {
             feeReceiver.transfer(address(this).balance);
            return;
        }
        IERC20 erc20token = IERC20(_token);
        uint256 balance = erc20token.balanceOf(address(this));
        erc20token.transfer(feeReceiver, balance);
    }
   
  
  

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"arrayLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"array_limit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_customer","type":"address"}],"name":"currentFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ethFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeReceiver","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address[]","name":"userAddresses","type":"address[]"},{"internalType":"uint256[]","name":"amountsOrIds","type":"uint256[]"}],"name":"multisendToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"erc721Addresses","type":"address[]"},{"internalType":"uint256[]","name":"erc721Ids","type":"uint256[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"send1155To721Ids","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"userAddresses","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"send1155ToAddresses","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"erc721Addresses","type":"address[]"},{"internalType":"uint256[]","name":"receiverIds","type":"uint256[]"},{"internalType":"uint256[]","name":"amountsOrIds","type":"uint256[]"},{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"send721Or20To721Ids","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"f","type":"uint256"}],"name":"setEthFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"a","type":"address"}],"name":"setFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

31062:4020:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30083:223;;;;;;;;;;-1:-1:-1;30083:223:0;;;;;:::i;:::-;;:::i;:::-;;;11660:14:1;;11653:22;11635:41;;11623:2;11608:18;30083:223:0;;;;;;;;32103:394;;;;;;:::i;:::-;;:::i;:::-;;32599:598;;;;;;:::i;:::-;;:::i;34631:70::-;;;;;;;;;;-1:-1:-1;34631:70:0;;;;;:::i;:::-;;:::i;31205:21::-;;;;;;;;;;;;;;;;;;;13509:25:1;;;13497:2;13482:18;31205:21:0;13363:177:1;31518:175:0;;;;;;;;;;-1:-1:-1;31518:175:0;;;;;:::i;:::-;;:::i;2534:94::-;;;;;;;;;;;;;:::i;1883:87::-;;;;;;;;;;-1:-1:-1;1956:6:0;;-1:-1:-1;;;;;1956:6:0;1883:87;;;-1:-1:-1;;;;;9030:32:1;;;9012:51;;9000:2;8985:18;1883:87:0;8866:203:1;33247:523:0;;;;;;:::i;:::-;;:::i;31166:34::-;;;;;;;;;;-1:-1:-1;31166:34:0;;;;-1:-1:-1;;;;;31166:34:0;;;31422:88;;;;;;;;;;-1:-1:-1;31491:11:0;;31422:88;;30747:255;;;;;;;;;;-1:-1:-1;30747:255:0;;;;;:::i;:::-;-1:-1:-1;;;30747:255:0;;;;;;;;;;;-1:-1:-1;;;;;;11849:33:1;;;11831:52;;11819:2;11804:18;30747:255:0;11687:202:1;31231:26:0;;;;;;;;;;;;;;;;34711:353;;;;;;;;;;-1:-1:-1;34711:353:0;;;;;:::i;:::-;;:::i;33827:672::-;;;;;;:::i;:::-;;:::i;34537:88::-;;;;;;;;;;-1:-1:-1;34537:88:0;;;;;:::i;:::-;;:::i;30512:227::-;;;;;;;;;;-1:-1:-1;30512:227:0;;;;;:::i;:::-;-1:-1:-1;;;30512:227:0;;;;;;;;2783:192;;;;;;;;;;-1:-1:-1;2783:192:0;;;;;:::i;:::-;;:::i;30083:223::-;30185:4;-1:-1:-1;;;;;;30209:49:0;;-1:-1:-1;;;30209:49:0;;:89;;-1:-1:-1;;;;;;;;;;27306:40:0;;;30262:36;30202:96;30083:223;-1:-1:-1;;30083:223:0:o;32103:394::-;4910:1;5506:7;;:19;;5498:63;;;;-1:-1:-1;;;5498:63:0;;;;;;;:::i;:::-;;;;;;;;;4910:1;5639:7;:18;32283:43;;::::1;32274:70;;;;-1:-1:-1::0;;;32274:70:0::1;;;;;;;:::i;:::-;32356:9;32351:141;32371:24:::0;;::::1;32351:141;;;32411:73;32424:12;32438:10;32450:13;;32464:1;32450:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;32468:12;;32481:1;32468:15;;;;;;;:::i;:::-;;;;;;;32411:12;:73::i;:::-;32397:3:::0;::::1;::::0;::::1;:::i;:::-;;;;32351:141;;;-1:-1:-1::0;;4866:1:0;5818:7;:22;-1:-1:-1;;;;32103:394:0:o;32599:598::-;4910:1;5506:7;;:19;;5498:63;;;;-1:-1:-1;;;5498:63:0;;;;;;;:::i;:::-;4910:1;5639:7;:18;32818:44;;::::1;32809:71;;;;-1:-1:-1::0;;;32809:71:0::1;;;;;;;:::i;:::-;32896:45:::0;;::::1;32887:72;;;;-1:-1:-1::0;;;32887:72:0::1;;;;;;;:::i;:::-;32971:9;32966:226;32986:22:::0;;::::1;32966:226;;;33024:24;33069:15;;33085:1;33069:18;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;33024:64;;33097:87;33110:12;33124:10;33136:6;-1:-1:-1::0;;;;;33136:14:0::1;;33151:11;;33163:1;33151:14;;;;;;;:::i;:::-;;;;;;;33136:30;;;;;;;;;;;;;13509:25:1::0;;13497:2;13482:18;;13363:177;33136:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33168:12;;33181:1;33168:15;;;;;;;:::i;33097:87::-;-1:-1:-1::0;33010:3:0;::::1;::::0;::::1;:::i;:::-;;;;32966:226;;;-1:-1:-1::0;;4866:1:0;5818:7;:22;-1:-1:-1;;;;;;32599:598:0:o;34631:70::-;1956:6;;-1:-1:-1;;;;;1956:6:0;751:10;2103:23;2095:68;;;;-1:-1:-1;;;2095:68:0;;;;;;;:::i;:::-;34685:6:::1;:10:::0;34631:70::o;31518:175::-;31577:7;-1:-1:-1;;;;;31600:25:0;;31597:64;;-1:-1:-1;31648:1:0;;31518:175;-1:-1:-1;31518:175:0:o;31597:64::-;-1:-1:-1;;31679:6:0;;;31518:175::o;2534:94::-;1956:6;;-1:-1:-1;;;;;1956:6:0;751:10;2103:23;2095:68;;;;-1:-1:-1;;;2095:68:0;;;;;;;:::i;:::-;2599:21:::1;2617:1;2599:9;:21::i;:::-;2534:94::o:0;33247:523::-;4910:1;5506:7;;:19;;5498:63;;;;-1:-1:-1;;;5498:63:0;;;;;;;:::i;:::-;4910:1;5639:7;:18;33456:38;;::::1;33447:65;;;;-1:-1:-1::0;;;33447:65:0::1;;;;;;;:::i;:::-;33528:39:::0;;::::1;33519:66;;;;-1:-1:-1::0;;;33519:66:0::1;;;;;;;:::i;:::-;33597:9;33592:173;33612:24:::0;;::::1;33592:173;;;33661:12;-1:-1:-1::0;;;;;33652:39:0::1;;33692:10;33704:13;;33718:1;33704:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;33722:8;;33731:1;33722:11;;;;;;;:::i;:::-;;;;;;;33735:7;;33743:1;33735:10;;;;;;;:::i;:::-;;;;;;;33747:9;33652:105;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;33638:3;;;;;:::i;:::-;;;;33592:173;;34711:353:::0;1956:6;;-1:-1:-1;;;;;1956:6:0;751:10;2103:23;2095:68;;;;-1:-1:-1;;;2095:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;34780:22:0;::::1;34776:120;;34820:11;::::0;:43:::1;::::0;-1:-1:-1;;;;;34820:11:0;;::::1;::::0;34841:21:::1;34820:43:::0;::::1;;;::::0;:11:::1;:43:::0;:11;:43;34841:21;34820:11;:43;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;34711:353:::0;:::o;34776:120::-:1;34969:35;::::0;-1:-1:-1;;;34969:35:0;;34998:4:::1;34969:35;::::0;::::1;9012:51:1::0;34933:6:0;;34906:17:::1;::::0;-1:-1:-1;;;;;34969:20:0;::::1;::::0;::::1;::::0;8985:18:1;;34969:35:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;35035:11;::::0;35015:41:::1;::::0;-1:-1:-1;;;35015:41:0;;-1:-1:-1;;;;;35035:11:0;;::::1;35015:41;::::0;::::1;9480:51:1::0;9547:18;;;9540:34;;;34951:53:0;;-1:-1:-1;35015:19:0;::::1;::::0;::::1;::::0;9453:18:1;;35015:41:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;34765:299;;2174:1;34711:353:::0;:::o;33827:672::-;4910:1;5506:7;;:19;;5498:63;;;;-1:-1:-1;;;5498:63:0;;;;;;;:::i;:::-;4910:1;5639:7;:18;34070:42;;::::1;34061:69;;;;-1:-1:-1::0;;;34061:69:0::1;;;;;;;:::i;:::-;34146:40:::0;;::::1;34137:67;;;;-1:-1:-1::0;;;34137:67:0::1;;;;;;;:::i;:::-;34220:41:::0;;::::1;34211:68;;;;-1:-1:-1::0;;;34211:68:0::1;;;;;;;:::i;:::-;34291:9;34286:208;34306:26:::0;;::::1;34286:208;;;34357:12;-1:-1:-1::0;;;;;34348:39:0::1;;34388:10;34408:15;;34424:1;34408:18;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;34400:35:0::1;;34436:9;;34446:1;34436:12;;;;;;;:::i;:::-;;;;;;;34400:49;;;;;;;;;;;;;13509:25:1::0;;13497:2;13482:18;;13363:177;34400:49:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;34451:8;;34460:1;34451:11;;;;;;;:::i;:::-;;;;;;;34464:7;;34472:1;34464:10;;;;;;;:::i;:::-;;;;;;;34476:9;34348:138;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;34334:3;;;;;:::i;:::-;;;;34286:208;;;-1:-1:-1::0;;4866:1:0;5818:7;:22;-1:-1:-1;;;;;;;;33827:672:0:o;34537:88::-;1956:6;;-1:-1:-1;;;;;1956:6:0;751:10;2103:23;2095:68;;;;-1:-1:-1;;;2095:68:0;;;;;;;:::i;:::-;34604:11:::1;:15:::0;;-1:-1:-1;;;;;;34604:15:0::1;-1:-1:-1::0;;;;;34604:15:0;;;::::1;::::0;;;::::1;::::0;;34537:88::o;2783:192::-;1956:6;;-1:-1:-1;;;;;1956:6:0;751:10;2103:23;2095:68;;;;-1:-1:-1;;;2095:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2872:22:0;::::1;2864:73;;;::::0;-1:-1:-1;;;2864:73:0;;12096:2:1;2864:73:0::1;::::0;::::1;12078:21:1::0;12135:2;12115:18;;;12108:30;12174:34;12154:18;;;12147:62;-1:-1:-1;;;12225:18:1;;;12218:36;12271:19;;2864:73:0::1;11894:402:1::0;2864:73:0::1;2948:19;2958:8;2948:9;:19::i;31822:168::-:0;31928:56;;-1:-1:-1;;;31928:56:0;;-1:-1:-1;;;;;9843:15:1;;;31928:56:0;;;9825:34:1;9895:15;;;9875:18;;;9868:43;9927:18;;;9920:34;;;31928::0;;;;;9760:18:1;;31928:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31822:168;;;;:::o;2983:173::-;3058:6;;;-1:-1:-1;;;;;3075:17:0;;;-1:-1:-1;;;;;;3075:17:0;;;;;;;3108:40;;3058:6;;;3075:17;3058:6;;3108:40;;3039:16;;3108:40;3028:128;2983:173;:::o;14:367:1:-;77:8;87:6;141:3;134:4;126:6;122:17;118:27;108:55;;159:1;156;149:12;108:55;-1:-1:-1;182:20:1;;225:18;214:30;;211:50;;;257:1;254;247:12;211:50;294:4;286:6;282:17;270:29;;354:3;347:4;337:6;334:1;330:14;322:6;318:27;314:38;311:47;308:67;;;371:1;368;361:12;308:67;14:367;;;;;:::o;386:723::-;440:5;493:3;486:4;478:6;474:17;470:27;460:55;;511:1;508;501:12;460:55;547:6;534:20;573:4;596:18;592:2;589:26;586:52;;;618:18;;:::i;:::-;664:2;661:1;657:10;687:28;711:2;707;703:11;687:28;:::i;:::-;749:15;;;780:12;;;;812:15;;;846;;;842:24;;839:33;-1:-1:-1;836:53:1;;;885:1;882;875:12;836:53;907:1;898:10;;917:163;931:2;928:1;925:9;917:163;;;988:17;;976:30;;949:1;942:9;;;;;1026:12;;;;1058;;917:163;;;-1:-1:-1;1098:5:1;386:723;-1:-1:-1;;;;;;;386:723:1:o;1114:530::-;1156:5;1209:3;1202:4;1194:6;1190:17;1186:27;1176:55;;1227:1;1224;1217:12;1176:55;1263:6;1250:20;1289:18;1285:2;1282:26;1279:52;;;1311:18;;:::i;:::-;1355:55;1398:2;1379:13;;-1:-1:-1;;1375:27:1;1404:4;1371:38;1355:55;:::i;:::-;1435:2;1426:7;1419:19;1481:3;1474:4;1469:2;1461:6;1457:15;1453:26;1450:35;1447:55;;;1498:1;1495;1488:12;1447:55;1563:2;1556:4;1548:6;1544:17;1537:4;1528:7;1524:18;1511:55;1611:1;1586:16;;;1604:4;1582:27;1575:38;;;;1590:7;1114:530;-1:-1:-1;;;1114:530:1:o;1649:247::-;1708:6;1761:2;1749:9;1740:7;1736:23;1732:32;1729:52;;;1777:1;1774;1767:12;1729:52;1816:9;1803:23;1835:31;1860:5;1835:31;:::i;:::-;1885:5;1649:247;-1:-1:-1;;;1649:247:1:o;1901:251::-;1971:6;2024:2;2012:9;2003:7;1999:23;1995:32;1992:52;;;2040:1;2037;2030:12;1992:52;2072:9;2066:16;2091:31;2116:5;2091:31;:::i;2417:1071::-;2571:6;2579;2587;2595;2603;2656:3;2644:9;2635:7;2631:23;2627:33;2624:53;;;2673:1;2670;2663:12;2624:53;2712:9;2699:23;2731:31;2756:5;2731:31;:::i;:::-;2781:5;-1:-1:-1;2838:2:1;2823:18;;2810:32;2851:33;2810:32;2851:33;:::i;:::-;2903:7;-1:-1:-1;2961:2:1;2946:18;;2933:32;2984:18;3014:14;;;3011:34;;;3041:1;3038;3031:12;3011:34;3064:61;3117:7;3108:6;3097:9;3093:22;3064:61;:::i;:::-;3054:71;;3178:2;3167:9;3163:18;3150:32;3134:48;;3207:2;3197:8;3194:16;3191:36;;;3223:1;3220;3213:12;3191:36;3246:63;3301:7;3290:8;3279:9;3275:24;3246:63;:::i;:::-;3236:73;;3362:3;3351:9;3347:19;3334:33;3318:49;;3392:2;3382:8;3379:16;3376:36;;;3408:1;3405;3398:12;3376:36;;3431:51;3474:7;3463:8;3452:9;3448:24;3431:51;:::i;:::-;3421:61;;;2417:1071;;;;;;;;:::o;3493:734::-;3597:6;3605;3613;3621;3629;3682:3;3670:9;3661:7;3657:23;3653:33;3650:53;;;3699:1;3696;3689:12;3650:53;3738:9;3725:23;3757:31;3782:5;3757:31;:::i;:::-;3807:5;-1:-1:-1;3864:2:1;3849:18;;3836:32;3877:33;3836:32;3877:33;:::i;:::-;3929:7;-1:-1:-1;3983:2:1;3968:18;;3955:32;;-1:-1:-1;4034:2:1;4019:18;;4006:32;;-1:-1:-1;4089:3:1;4074:19;;4061:33;4117:18;4106:30;;4103:50;;;4149:1;4146;4139:12;4103:50;4172:49;4213:7;4204:6;4193:9;4189:22;4172:49;:::i;4232:908::-;4363:6;4371;4379;4387;4395;4448:2;4436:9;4427:7;4423:23;4419:32;4416:52;;;4464:1;4461;4454:12;4416:52;4503:9;4490:23;4522:31;4547:5;4522:31;:::i;:::-;4572:5;-1:-1:-1;4628:2:1;4613:18;;4600:32;4651:18;4681:14;;;4678:34;;;4708:1;4705;4698:12;4678:34;4747:70;4809:7;4800:6;4789:9;4785:22;4747:70;:::i;:::-;4836:8;;-1:-1:-1;4721:96:1;-1:-1:-1;4924:2:1;4909:18;;4896:32;;-1:-1:-1;4940:16:1;;;4937:36;;;4969:1;4966;4959:12;4937:36;;5008:72;5072:7;5061:8;5050:9;5046:24;5008:72;:::i;:::-;4232:908;;;;-1:-1:-1;4232:908:1;;-1:-1:-1;5099:8:1;;4982:98;4232:908;-1:-1:-1;;;4232:908:1:o;5145:1224::-;5312:6;5320;5328;5336;5344;5352;5360;5413:3;5401:9;5392:7;5388:23;5384:33;5381:53;;;5430:1;5427;5420:12;5381:53;5470:9;5457:23;5499:18;5540:2;5532:6;5529:14;5526:34;;;5556:1;5553;5546:12;5526:34;5595:70;5657:7;5648:6;5637:9;5633:22;5595:70;:::i;:::-;5684:8;;-1:-1:-1;5569:96:1;-1:-1:-1;5772:2:1;5757:18;;5744:32;;-1:-1:-1;5788:16:1;;;5785:36;;;5817:1;5814;5807:12;5785:36;5856:72;5920:7;5909:8;5898:9;5894:24;5856:72;:::i;:::-;5947:8;;-1:-1:-1;5830:98:1;-1:-1:-1;6035:2:1;6020:18;;6007:32;;-1:-1:-1;6051:16:1;;;6048:36;;;6080:1;6077;6070:12;6048:36;;6119:72;6183:7;6172:8;6161:9;6157:24;6119:72;:::i;:::-;6210:8;;-1:-1:-1;6093:98:1;-1:-1:-1;;6295:2:1;6280:18;;6267:32;6308:31;6267:32;6308:31;:::i;:::-;6358:5;6348:15;;;5145:1224;;;;;;;;;;:::o;6374:1540::-;6577:6;6585;6593;6601;6609;6617;6625;6633;6641;6694:3;6682:9;6673:7;6669:23;6665:33;6662:53;;;6711:1;6708;6701:12;6662:53;6751:9;6738:23;6780:18;6821:2;6813:6;6810:14;6807:34;;;6837:1;6834;6827:12;6807:34;6876:70;6938:7;6929:6;6918:9;6914:22;6876:70;:::i;:::-;6965:8;;-1:-1:-1;6850:96:1;-1:-1:-1;7053:2:1;7038:18;;7025:32;;-1:-1:-1;7069:16:1;;;7066:36;;;7098:1;7095;7088:12;7066:36;7137:72;7201:7;7190:8;7179:9;7175:24;7137:72;:::i;:::-;7228:8;;-1:-1:-1;7111:98:1;-1:-1:-1;7316:2:1;7301:18;;7288:32;;-1:-1:-1;7332:16:1;;;7329:36;;;7361:1;7358;7351:12;7329:36;7400:72;7464:7;7453:8;7442:9;7438:24;7400:72;:::i;:::-;7491:8;;-1:-1:-1;7374:98:1;-1:-1:-1;7579:2:1;7564:18;;7551:32;;-1:-1:-1;7595:16:1;;;7592:36;;;7624:1;7621;7614:12;7592:36;;7663:72;7727:7;7716:8;7705:9;7701:24;7663:72;:::i;:::-;7754:8;;-1:-1:-1;7637:98:1;-1:-1:-1;;7839:3:1;7824:19;;7811:33;7853:31;7811:33;7853:31;:::i;:::-;7903:5;7893:15;;;6374:1540;;;;;;;;;;;:::o;7919:277::-;7986:6;8039:2;8027:9;8018:7;8014:23;8010:32;8007:52;;;8055:1;8052;8045:12;8007:52;8087:9;8081:16;8140:5;8133:13;8126:21;8119:5;8116:32;8106:60;;8162:1;8159;8152:12;8201:286;8259:6;8312:2;8300:9;8291:7;8287:23;8283:32;8280:52;;;8328:1;8325;8318:12;8280:52;8354:23;;-1:-1:-1;;;;;;8406:32:1;;8396:43;;8386:71;;8453:1;8450;8443:12;8492:180;8551:6;8604:2;8592:9;8583:7;8579:23;8575:32;8572:52;;;8620:1;8617;8610:12;8572:52;-1:-1:-1;8643:23:1;;8492:180;-1:-1:-1;8492:180:1:o;8677:184::-;8747:6;8800:2;8788:9;8779:7;8775:23;8771:32;8768:52;;;8816:1;8813;8806:12;8768:52;-1:-1:-1;8839:16:1;;8677:184;-1:-1:-1;8677:184:1:o;9965:1525::-;-1:-1:-1;;;;;10259:15:1;;;10241:34;;10332:15;;10294:2;10312:18;;;10305:43;;;;10379:2;10364:18;;10357:34;;;10422:2;10407:18;;10400:34;;;10221:3;10465;10450:19;;10443:32;10522:13;;10184:4;;;;10230:1;10600:18;;;;10653;;;;10680:61;;10734:4;10726:6;10722:17;10712:27;;10680:61;10787:2;10779:6;10776:14;10756:18;10753:38;10750:165;;;-1:-1:-1;;;10814:33:1;;10870:4;10867:1;10860:15;10900:4;10821:3;10888:17;10750:165;10985:3;10970:19;;14036;;;14079:14;;;11014:18;11041:100;;;;11155:1;11150:314;;;;11007:457;;11041:100;-1:-1:-1;;11074:24:1;;11062:37;;11119:12;;;;-1:-1:-1;11041:100:1;;11150:314;13897:1;13890:14;;;13934:4;13921:18;;11244:1;11258:165;11272:6;11269:1;11266:13;11258:165;;;11350:14;;11337:11;;;11330:35;11393:16;;;;11287:10;;11258:165;;;11443:11;;;-1:-1:-1;;11007:457:1;-1:-1:-1;11481:3:1;;9965:1525;-1:-1:-1;;;;;;;;;;;;;9965:1525:1:o;12301:336::-;12503:2;12485:21;;;12542:2;12522:18;;;12515:30;-1:-1:-1;;;12576:2:1;12561:18;;12554:42;12628:2;12613:18;;12301:336::o;12642:356::-;12844:2;12826:21;;;12863:18;;;12856:30;12922:34;12917:2;12902:18;;12895:62;12989:2;12974:18;;12642:356::o;13003:355::-;13205:2;13187:21;;;13244:2;13224:18;;;13217:30;13283:33;13278:2;13263:18;;13256:61;13349:2;13334:18;;13003:355::o;13545:275::-;13616:2;13610:9;13681:2;13662:13;;-1:-1:-1;;13658:27:1;13646:40;;13716:18;13701:34;;13737:22;;;13698:62;13695:88;;;13763:18;;:::i;:::-;13799:2;13792:22;13545:275;;-1:-1:-1;13545:275:1:o;14104:232::-;14143:3;-1:-1:-1;;14164:17:1;;14161:140;;;14223:10;14218:3;14214:20;14211:1;14204:31;14258:4;14255:1;14248:15;14286:4;14283:1;14276:15;14161:140;-1:-1:-1;14328:1:1;14317:13;;14104:232::o;14341:127::-;14402:10;14397:3;14393:20;14390:1;14383:31;14433:4;14430:1;14423:15;14457:4;14454:1;14447:15;14473:127;14534:10;14529:3;14525:20;14522:1;14515:31;14565:4;14562:1;14555:15;14589:4;14586:1;14579:15;14605:131;-1:-1:-1;;;;;14680:31:1;;14670:42;;14660:70;;14726:1;14723;14716:12

ipfs://84717fba7df76b8d905d90fcd6f8d68929f8f13664f2e678c4b481f86ab3b36d