Contract 0x7763fe0df38d9bdafda6fc9da127544b30fa0775

/**
 *Submitted for verification at snowtrace.io on 2022-12-18
*/

// SPDX-License-Identifier: MIT

/*
╭╮╭╮╭┳━━━┳━╮╱╭┳━━━┳━━━┳━━━┳╮╱╱╭━━━┳━╮╱╭┳━━━╮
┃┃┃┃┃┃╭━╮┃┃╰╮┃┣╮╭╮┃╭━━┫╭━╮┃┃╱╱┃╭━╮┃┃╰╮┃┣╮╭╮┃
┃┃┃┃┃┃┃╱┃┃╭╮╰╯┃┃┃┃┃╰━━┫╰━╯┃┃╱╱┃┃╱┃┃╭╮╰╯┃┃┃┃┃
┃╰╯╰╯┃┃╱┃┃┃╰╮┃┃┃┃┃┃╭━━┫╭╮╭┫┃╱╭┫╰━╯┃┃╰╮┃┃┃┃┃┃
╰╮╭╮╭┫╰━╯┃┃╱┃┃┣╯╰╯┃╰━━┫┃┃╰┫╰━╯┃╭━╮┃┃╱┃┃┣╯╰╯┃
╱╰╯╰╯╰━━━┻╯╱╰━┻━━━┻━━━┻╯╰━┻━━━┻╯╱╰┻╯╱╰━┻━━━╯
╭━━━┳━━━┳━━━┳━━━┳━╮╭━┳━━━┳━━━━┳━━┳━━━┳━╮╱╭╮
┃╭━╮┃╭━━┻╮╭╮┃╭━━┫┃╰╯┃┃╭━╮┃╭╮╭╮┣┫┣┫╭━╮┃┃╰╮┃┃
┃╰━╯┃╰━━╮┃┃┃┃╰━━┫╭╮╭╮┃╰━╯┣╯┃┃╰╯┃┃┃┃╱┃┃╭╮╰╯┃
┃╭╮╭┫╭━━╯┃┃┃┃╭━━┫┃┃┃┃┃╭━━╯╱┃┃╱╱┃┃┃┃╱┃┃┃╰╮┃┃
┃┃┃╰┫╰━━┳╯╰╯┃╰━━┫┃┃┃┃┃┃╱╱╱╱┃┃╱╭┫┣┫╰━╯┃┃╱┃┃┃
╰╯╰━┻━━━┻━━━┻━━━┻╯╰╯╰┻╯╱╱╱╱╰╯╱╰━━┻━━━┻╯╱╰━╯
*/

// File: contracts/interfaces/IRedemption.sol



pragma solidity 0.8.17;

interface IRedemption {
    function redeem(
        uint256 _amountIn,
        uint256 _amount,
        bytes32[] calldata _merkleProof
    ) external;
}

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
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) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (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 generally not needed starting with Solidity 0.8, since 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 subtraction 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/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

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

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;




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

// File: @openzeppelin/contracts/utils/Context.sol


// 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;
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (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() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: contracts/Redemption.sol



pragma solidity 0.8.17;

/**
 * @title Redemption
 * @author Wonderland DAO
 */

contract Redemption is IRedemption, Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    /* ============ Events ============ */

    event RedemptionTokenAdded(address indexed token, uint256 exchangeRate);
    event RedemptionTokenRemoved(address indexed token);
    event Redeemed(address indexed redeemer, uint256 amountIn, uint256 amount);
    event TreasurySet(address indexed treasury);
    event BurnerSet(address indexed burner);
    event MerkleRootSet(bytes32 indexed merkleRoot);
    event RedemptionStarted(uint256 start, uint256 stop);
    event RedemptionResetted();

    /* ============ State Variables ============ */

    struct Claim {
        // Cummulative amount of redeemed tokens in recent redmeption.
        uint256 amount;
        // Last time claim was made.
        uint256 lastClaimed;
    }

    IERC20 public immutable redeemableToken;
    uint256 public immutable redeemableTokenDecimals;

    uint256 public redemptionStart;
    uint256 public redemptionStop;
    bytes32 public merkleRoot;
    address public treasury;
    address public burner;

    mapping(IERC20 => uint256) public exchangeRates;
    mapping(address => Claim) public claims;
    IERC20[] public redemptionTokens;

    bool private _isRedemptionResetted;

    /* ============ Constructor ============ */

    constructor(address _redeemableToken, uint256 _decimals) {
        require(
            _redeemableToken != address(0),
            "Redeemable token is address zero"
        );
        require(_decimals > 0, "Decimals cannot be zero");
        redeemableToken = IERC20(_redeemableToken);
        redeemableTokenDecimals = _decimals;
        _isRedemptionResetted = true;
    }

    /* ============ Modifiers ============ */

    modifier onActiveRedemption() {
        require(isRedemptionActive() == true, "Redemption is not active yet");
        _;
    }

    modifier onInactiveRedemption() {
        require(isRedemptionActive() == false, "Redemption period is active");
        _;
    }

    modifier afterRedemptionReset() {
        require(
            _isRedemptionResetted == true,
            "Assets not claimed by treasury"
        );
        _;
    }

    /* ============ External Functions ============ */

    /**
     * @notice Redeem redeemable token for redemption tokens.
     *
     * @dev If cummulative redeems exceed `_amount` redeem will fail.
     *
     * @param _amountIn Amount of redeemable token to reedem.
     * @param _amount Max cummulative redeemable amount for msg.sender, included in `_merkleProof`.
     * @param _merkleProof Merkle proof of amount for `msg.sender` account.
     */
    function redeem(
        uint256 _amountIn,
        uint256 _amount,
        bytes32[] calldata _merkleProof
    ) external onActiveRedemption {
        require(_amountIn > 0, "Cannot redeem zero tokens");

        // Reset claimed amount.
        Claim storage claim = claims[msg.sender];
        if (claim.lastClaimed <= redemptionStart) {
            claim.amount = 0;
        }

        // Verify amount to redeem.
        uint256 newAmountClaimed = _amountIn + claim.amount;
        require(
            newAmountClaimed <= _amount,
            "Amount is larger than redeemable"
        );

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(msg.sender, _amount));
        require(
            MerkleProof.verify(_merkleProof, merkleRoot, node),
            "MerkleDistributor: Invalid Proof"
        );

        // Send redeemable token to burner address.
        claim.amount = newAmountClaimed;
        claim.lastClaimed = block.timestamp;
        redeemableToken.safeTransferFrom(msg.sender, burner, _amountIn);

        // Send redemption tokens to msg.sender.
        uint256 length = redemptionTokens.length;
        for (uint256 i; i < length; i++) {
            IERC20 _redemptionToken = redemptionTokens[i];
            uint256 amountToReceive = _amountIn
                .mul(exchangeRates[_redemptionToken])
                .div(10**redeemableTokenDecimals);
            _redemptionToken.safeTransfer(msg.sender, amountToReceive);
        }

        emit Redeemed(msg.sender, _amountIn, _amount);
    }

    /* ============ External View Functions ============ */

    /**
     * @notice Return length of `redemptionTokens` list.
     */
    function redemptionTokensLength() external view returns (uint256) {
        return redemptionTokens.length;
    }

    /**
     * @notice Return already claimed amount in current/most recent redemption.
     *
     * @param _account Address against which to check claimed amount.
     */
    function claimedCurrentRedemption(address _account)
        external
        view
        returns (uint256 claimed)
    {
        Claim storage claim = claims[_account];
        if (claim.lastClaimed <= redemptionStart) {
            claimed = 0;
        } else {
            claimed = claim.amount;
        }
    }

    /**
     * @notice Return boolean if the redemption is active.
     */
    function isRedemptionActive() public view returns (bool) {
        if (block.timestamp < redemptionStop) return true;
        else return false;
    }

    /* ============ External Owner Functions ============ */

    /**
     * @notice Add IERC20 token to redeem on next redemption.
     *
     * @dev Only callable in between redemptions and after reset.
     *
     * @param _redemptionToken Address of IERC20 token to add.
     * @param _exchangeRate Rate of how many tokens to redeem per 1 redeemable token.
     */
    function addRedemptionToken(IERC20 _redemptionToken, uint256 _exchangeRate)
        public
        onInactiveRedemption
        afterRedemptionReset
        onlyOwner
    {
        require(
            _redemptionToken != redeemableToken,
            "Token cannot be redeemable token"
        );
        require(address(_redemptionToken) != address(0), "Token address zero");
        require(_exchangeRate > 0, "Exchange rate zero");

        uint256 length = redemptionTokens.length;
        for (uint256 i; i < length; i++) {
            require(
                redemptionTokens[i] != _redemptionToken,
                "Token already exists"
            );
        }

        redemptionTokens.push(_redemptionToken);
        exchangeRates[_redemptionToken] = _exchangeRate;

        emit RedemptionTokenAdded(address(_redemptionToken), _exchangeRate);
    }

    /**
     * @notice Remove IERC20 token from next redemption.
     *
     * @dev Only callable in between redemptions and after reset.
     *
     * @param _index Index of redemption token.
     * @param _token Address of IERC20 token to remove.
     */
    function removeRedemptionToken(uint256 _index, address _token)
        public
        onInactiveRedemption
        afterRedemptionReset
        onlyOwner
    {
        uint256 length = redemptionTokens.length;
        require(_index < length, "Index doesn't exist");

        IERC20 redemptionToken = redemptionTokens[_index];
        require(
            address(redemptionToken) == _token,
            "Sanity: Token address mismatch"
        );

        exchangeRates[redemptionToken] = 0;
        redemptionTokens[_index] = redemptionTokens[length - 1];
        redemptionTokens.pop();

        emit RedemptionTokenRemoved(_token);
    }

    /**
     * @notice Set treasury address for next redemption.
     *
     * @dev Only callable in between redemptions and after reset.
     *
     * @param _treasury Address of the treasury.
     */
    function setTreasury(address _treasury)
        external
        onInactiveRedemption
        afterRedemptionReset
        onlyOwner
    {
        require(_treasury != address(0), "Treasury address zero");
        treasury = _treasury;
        emit TreasurySet(_treasury);
    }

    /**
     * @notice Set burner address for next redemption.
     *
     * @dev Only callable in between redemptions and after reset.
     *
     * @param _burner Address to which redeemable tokens will be sent.
     */
    function setBurner(address _burner)
        external
        onInactiveRedemption
        afterRedemptionReset
        onlyOwner
    {
        require(_burner != address(0), "Burner address zero");
        burner = _burner;
        emit BurnerSet(_burner);
    }

    /**
     * @notice Set merkle root for next redemption.
     *
     * @dev Only callable in between redemptions and afer reset.
     *
     * @param _merkleRoot Root of merkle tree used for proving redemption rights.
     */
    function setMerkleRoot(bytes32 _merkleRoot)
        external
        onInactiveRedemption
        afterRedemptionReset
        onlyOwner
    {
        require(_merkleRoot != bytes32(0), "Merkle Root zero");
        merkleRoot = _merkleRoot;
        emit MerkleRootSet(_merkleRoot);
    }

    /**
     * @notice Start redemption period.
     *
     * @dev Only callable in between redemptions and afer reset.
     *
     * @param _deadline Timestamp on which redemption will end.
     */
    function startRedemption(uint256 _deadline)
        external
        onInactiveRedemption
        afterRedemptionReset
        onlyOwner
    {
        require(burner != address(0), "Burner address zero");
        require(treasury != address(0), "Treasury address zero");
        require(merkleRoot != bytes32(0), "Merkle Root zero");
        require(redemptionTokens.length > 0, "No redemption tokens added");
        require(_deadline > block.timestamp, "Deadline in the past");

        _isRedemptionResetted = false;
        redemptionStart = block.timestamp;
        redemptionStop = _deadline;

        emit RedemptionStarted(redemptionStart, redemptionStop);
    }

    /**
     * @notice Reset redemption and all parameters, send all remaining tokens to treasury.
     *
     * @dev May be called any time, ends active redemptions.
     */
    function resetRedemption() external onlyOwner {
        require(treasury != address(0), "Treasury address zero");

        uint256 length = redemptionTokens.length;
        for (uint256 i; i < length; i++) {
            IERC20 redemptionToken = redemptionTokens[i];
            redemptionToken.safeTransfer(
                treasury,
                redemptionToken.balanceOf(address(this))
            );
        }

        burner = address(0);
        treasury = address(0);
        merkleRoot = bytes32(0);
        if (redemptionStop > block.timestamp) redemptionStop = block.timestamp;
        _isRedemptionResetted = true;

        emit RedemptionResetted();
    }

    /**
     * @notice Send IERC20 token to the treasury.
     *
     * @dev Only callable in between redemptions and after reset.
     *
     * @param _token Address of IERC20 token to recover.
     */
    function recoverERC20(IERC20 _token)
        external
        onInactiveRedemption
        afterRedemptionReset
        onlyOwner
    {
        require(treasury != address(0), "Treasury address zero");
        _token.safeTransfer(treasury, _token.balanceOf(address(this)));
    }
}

[{"inputs":[{"internalType":"address","name":"_redeemableToken","type":"address"},{"internalType":"uint256","name":"_decimals","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"burner","type":"address"}],"name":"BurnerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"MerkleRootSet","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":"redeemer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Redeemed","type":"event"},{"anonymous":false,"inputs":[],"name":"RedemptionResetted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"start","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"stop","type":"uint256"}],"name":"RedemptionStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"exchangeRate","type":"uint256"}],"name":"RedemptionTokenAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"RedemptionTokenRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"treasury","type":"address"}],"name":"TreasurySet","type":"event"},{"inputs":[{"internalType":"contract IERC20","name":"_redemptionToken","type":"address"},{"internalType":"uint256","name":"_exchangeRate","type":"uint256"}],"name":"addRedemptionToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"claimedCurrentRedemption","outputs":[{"internalType":"uint256","name":"claimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claims","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"lastClaimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"exchangeRates","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isRedemptionActive","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":"contract IERC20","name":"_token","type":"address"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"redeemableToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"redeemableTokenDecimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"redemptionStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"redemptionStop","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"redemptionTokens","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"redemptionTokensLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"},{"internalType":"address","name":"_token","type":"address"}],"name":"removeRedemptionToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resetRedemption","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_burner","type":"address"}],"name":"setBurner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"startRedemption","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000000da67235dd5787d67955420c84ca1cecd4e5bb3b0000000000000000000000000000000000000000000000000000000000000012

-----Decoded View---------------
Arg [0] : _redeemableToken (address): 0x0da67235dd5787d67955420c84ca1cecd4e5bb3b
Arg [1] : _decimals (uint256): 18

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000da67235dd5787d67955420c84ca1cecd4e5bb3b
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000012

41379:11399:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42620:32;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;378:32:1;;;360:51;;348:2;333:18;42620:32:0;;;;;;;;42252:39;;;;;51582:688;;;:::i;:::-;;46169:326;;;;;;:::i;:::-;;:::i;:::-;;;956:25:1;;;944:2;929:18;46169:326:0;810:177:1;42490:21:0;;;;;-1:-1:-1;;;;;42490:21:0;;;46581:153;;;:::i;:::-;;;1365:14:1;;1358:22;1340:41;;1328:2;1313:18;46581:153:0;1200:187:1;42428:25:0;;;;;;42298:48;;;;;50707:687;;;;;;:::i;:::-;;:::i;48280:661::-;;;;;;:::i;:::-;;:::i;42460:23::-;;;;;-1:-1:-1;;;;;42460:23:0;;;45868:115;45952:16;:23;45868:115;;40433:103;;;:::i;50197:296::-;;;;;;:::i;:::-;;:::i;42520:47::-;;;;;;:::i;:::-;;;;;;;;;;;;;;39785:87;39831:7;39858:6;-1:-1:-1;;;;;39858:6:0;39785:87;;52488:287;;;;;;:::i;:::-;;:::i;47121:886::-;;;;;;:::i;:::-;;:::i;49682:271::-;;;;;;:::i;:::-;;:::i;44123:1598::-;;;;;;:::i;:::-;;:::i;42574:39::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;3611:25:1;;;3667:2;3652:18;;3645:34;;;;3584:18;42574:39:0;3437:248:1;42355:30:0;;;;;;42392:29;;;;;;49158:287;;;;;;:::i;:::-;;:::i;40691:201::-;;;;;;:::i;:::-;;:::i;42620:32::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42620:32:0;;-1:-1:-1;42620:32:0;:::o;51582:688::-;39671:13;:11;:13::i;:::-;51647:8:::1;::::0;-1:-1:-1;;;;;51647:8:0::1;51639:56;;;;-1:-1:-1::0;;;51639:56:0::1;;;;;;;:::i;:::-;;;;;;;;;51725:16;:23:::0;51708:14:::1;51759:248;51779:6;51775:1;:10;51759:248;;;51807:22;51832:16;51849:1;51832:19;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;51913:8:::1;::::0;;51940:40:::1;::::0;-1:-1:-1;;;51940:40:0;;51974:4:::1;51940:40:::0;;::::1;360:51:1::0;;;;-1:-1:-1;;;;;51832:19:0;;::::1;::::0;-1:-1:-1;51866:129:0::1;::::0;51913:8:::1;::::0;51832:19;;51940:25:::1;::::0;333:18:1;;51940:40:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;51866:28:0;::::1;::::0;:129;:28:::1;:129::i;:::-;-1:-1:-1::0;51787:3:0;::::1;::::0;::::1;:::i;:::-;;;;51759:248;;;-1:-1:-1::0;52019:6:0::1;:19:::0;;-1:-1:-1;;;;;;52019:19:0;;::::1;::::0;;;52049:8:::1;:21:::0;;;;::::1;::::0;;52036:1:::1;52081:10;:23:::0;-1:-1:-1;52119:14:0;52136:15:::1;-1:-1:-1::0;52115:70:0::1;;;52170:15;52153:14;:32:::0;52115:70:::1;52196:21;:28:::0;;-1:-1:-1;;52196:28:0::1;52220:4;52196:28;::::0;;52242:20:::1;::::0;::::1;::::0;52196:21:::1;::::0;52242:20:::1;51628:642;51582:688::o:0;46169:326::-;-1:-1:-1;;;;;46326:16:0;;46271:15;46326:16;;;:6;:16;;;;;46378:15;;;46357:17;;;;:36;46353:135;;46420:1;46410:11;;46353:135;;;46464:12;;;-1:-1:-1;46353:135:0;46293:202;46169:326;;;:::o;46581:153::-;46632:4;46671:14;;46653:15;:32;46649:77;;;-1:-1:-1;46694:4:0;;46581:153::o;46649:77::-;-1:-1:-1;46721:5:0;;46581:153::o;50707:687::-;43387:20;:18;:20::i;:::-;:29;43379:69;;;;-1:-1:-1;;;43379:69:0;;;;;;;:::i;:::-;43541:21:::1;::::0;::::1;;:29;;:21:::0;:29:::1;43519:109;;;;-1:-1:-1::0;;;43519:109:0::1;;;;;;;:::i;:::-;39671:13:::2;:11;:13::i;:::-;50872:6:::3;::::0;-1:-1:-1;;;;;50872:6:0::3;50864:52;;;::::0;-1:-1:-1;;;50864:52:0;;5550:2:1;50864:52:0::3;::::0;::::3;5532:21:1::0;5589:2;5569:18;;;5562:30;-1:-1:-1;;;5608:18:1;;;5601:49;5667:18;;50864:52:0::3;5348:343:1::0;50864:52:0::3;50935:8;::::0;-1:-1:-1;;;;;50935:8:0::3;50927:56;;;;-1:-1:-1::0;;;50927:56:0::3;;;;;;;:::i;:::-;51002:10;::::0;50994:53:::3;;;::::0;-1:-1:-1;;;50994:53:0;;5898:2:1;50994:53:0::3;::::0;::::3;5880:21:1::0;5937:2;5917:18;;;5910:30;-1:-1:-1;;;5956:18:1;;;5949:46;6012:18;;50994:53:0::3;5696:340:1::0;50994:53:0::3;51066:16;:23:::0;51058:66:::3;;;::::0;-1:-1:-1;;;51058:66:0;;6243:2:1;51058:66:0::3;::::0;::::3;6225:21:1::0;6282:2;6262:18;;;6255:30;6321:28;6301:18;;;6294:56;6367:18;;51058:66:0::3;6041:350:1::0;51058:66:0::3;51155:15;51143:9;:27;51135:60;;;::::0;-1:-1:-1;;;51135:60:0;;6598:2:1;51135:60:0::3;::::0;::::3;6580:21:1::0;6637:2;6617:18;;;6610:30;-1:-1:-1;;;6656:18:1;;;6649:50;6716:18;;51135:60:0::3;6396:344:1::0;51135:60:0::3;51208:21;:29:::0;;-1:-1:-1;;51208:29:0::3;::::0;;51266:15:::3;-1:-1:-1::0;51248:33:0;;;51292:14:::3;:26:::0;;;51336:50:::3;::::0;;3611:25:1;;;3667:2;3652:18;;3645:34;;;51336:50:0::3;::::0;3584:18:1;51336:50:0::3;;;;;;;50707:687:::0;:::o;48280:661::-;43387:20;:18;:20::i;:::-;:29;43379:69;;;;-1:-1:-1;;;43379:69:0;;;;;;;:::i;:::-;43541:21:::1;::::0;::::1;;:29;;:21:::0;:29:::1;43519:109;;;;-1:-1:-1::0;;;43519:109:0::1;;;;;;;:::i;:::-;39671:13:::2;:11;:13::i;:::-;48471:16:::3;:23:::0;48513:15;;::::3;48505:47;;;::::0;-1:-1:-1;;;48505:47:0;;6947:2:1;48505:47:0::3;::::0;::::3;6929:21:1::0;6986:2;6966:18;;;6959:30;-1:-1:-1;;;7005:18:1;;;6998:49;7064:18;;48505:47:0::3;6745:343:1::0;48505:47:0::3;48565:22;48590:16;48607:6;48590:24;;;;;;;;:::i;:::-;;::::0;;;::::3;::::0;;;::::3;::::0;-1:-1:-1;;;;;48590:24:0;;::::3;::::0;-1:-1:-1;48647:34:0;::::3;::::0;::::3;48625:114;;;::::0;-1:-1:-1;;;48625:114:0;;7295:2:1;48625:114:0::3;::::0;::::3;7277:21:1::0;7334:2;7314:18;;;7307:30;7373:32;7353:18;;;7346:60;7423:18;;48625:114:0::3;7093:354:1::0;48625:114:0::3;-1:-1:-1::0;;;;;48752:30:0;::::3;48785:1;48752:30:::0;;;:13:::3;:30;::::0;;;;:34;48824:16:::3;48841:10;48850:1;48841:6:::0;:10:::3;:::i;:::-;48824:28;;;;;;;;:::i;:::-;;::::0;;;::::3;::::0;;;::::3;::::0;48797:16:::3;:24:::0;;-1:-1:-1;;;;;48824:28:0;;::::3;::::0;48814:6;;48797:24;::::3;;;;;:::i;:::-;;;;;;;;;:55;;;;;-1:-1:-1::0;;;;;48797:55:0::3;;;;;-1:-1:-1::0;;;;;48797:55:0::3;;;;;;48863:16;:22;;;;;;;:::i;:::-;;::::0;;;::::3;::::0;;;;-1:-1:-1;;48863:22:0;;;;;-1:-1:-1;;;;;;48863:22:0::3;::::0;;;;;;;;48903:30:::3;::::0;-1:-1:-1;;;;;48903:30:0;::::3;::::0;::::3;::::0;::::3;48443:498;;48280:661:::0;;:::o;40433:103::-;39671:13;:11;:13::i;:::-;40498:30:::1;40525:1;40498:18;:30::i;:::-;40433:103::o:0;50197:296::-;43387:20;:18;:20::i;:::-;:29;43379:69;;;;-1:-1:-1;;;43379:69:0;;;;;;;:::i;:::-;43541:21:::1;::::0;::::1;;:29;;:21:::0;:29:::1;43519:109;;;;-1:-1:-1::0;;;43519:109:0::1;;;;;;;:::i;:::-;39671:13:::2;:11;:13::i;:::-;50362:11:::0;50354:54:::3;;;::::0;-1:-1:-1;;;50354:54:0;;5898:2:1;50354:54:0::3;::::0;::::3;5880:21:1::0;5937:2;5917:18;;;5910:30;-1:-1:-1;;;5956:18:1;;;5949:46;6012:18;;50354:54:0::3;5696:340:1::0;50354:54:0::3;50419:10;:24:::0;;;50459:26:::3;::::0;50432:11;;50459:26:::3;::::0;;;::::3;50197:296:::0;:::o;52488:287::-;43387:20;:18;:20::i;:::-;:29;43379:69;;;;-1:-1:-1;;;43379:69:0;;;;;;;:::i;:::-;43541:21:::1;::::0;::::1;;:29;;:21:::0;:29:::1;43519:109;;;;-1:-1:-1::0;;;43519:109:0::1;;;;;;;:::i;:::-;39671:13:::2;:11;:13::i;:::-;52646:8:::3;::::0;-1:-1:-1;;;;;52646:8:0::3;52638:56;;;;-1:-1:-1::0;;;52638:56:0::3;;;;;;;:::i;:::-;52725:8;::::0;;52735:31:::3;::::0;-1:-1:-1;;;52735:31:0;;52760:4:::3;52735:31:::0;;::::3;360:51:1::0;;;;52705:62:0::3;::::0;-1:-1:-1;;;;;52725:8:0;;::::3;::::0;52735:16;::::3;::::0;::::3;::::0;333:18:1;;52735:31:0::3;199:218:1::0;52705:62:0::3;52488:287:::0;:::o;47121:886::-;43387:20;:18;:20::i;:::-;:29;43379:69;;;;-1:-1:-1;;;43379:69:0;;;;;;;:::i;:::-;43541:21:::1;::::0;::::1;;:29;;:21:::0;:29:::1;43519:109;;;;-1:-1:-1::0;;;43519:109:0::1;;;;;;;:::i;:::-;39671:13:::2;:11;:13::i;:::-;47350:15:::3;-1:-1:-1::0;;;;;47330:35:0::3;:16;-1:-1:-1::0;;;;;47330:35:0::3;::::0;47308:117:::3;;;::::0;-1:-1:-1;;;47308:117:0;;7919:2:1;47308:117:0::3;::::0;::::3;7901:21:1::0;;;7938:18;;;7931:30;7997:34;7977:18;;;7970:62;8049:18;;47308:117:0::3;7717:356:1::0;47308:117:0::3;-1:-1:-1::0;;;;;47444:39:0;::::3;47436:70;;;::::0;-1:-1:-1;;;47436:70:0;;8280:2:1;47436:70:0::3;::::0;::::3;8262:21:1::0;8319:2;8299:18;;;8292:30;-1:-1:-1;;;8338:18:1;;;8331:48;8396:18;;47436:70:0::3;8078:342:1::0;47436:70:0::3;47541:1;47525:13;:17;47517:48;;;::::0;-1:-1:-1;;;47517:48:0;;8627:2:1;47517:48:0::3;::::0;::::3;8609:21:1::0;8666:2;8646:18;;;8639:30;-1:-1:-1;;;8685:18:1;;;8678:48;8743:18;;47517:48:0::3;8425:342:1::0;47517:48:0::3;47595:16;:23:::0;47578:14:::3;47629:181;47649:6;47645:1;:10;47629:181;;;47726:16;-1:-1:-1::0;;;;;47703:39:0::3;:16;47720:1;47703:19;;;;;;;;:::i;:::-;;::::0;;;::::3;::::0;;;::::3;::::0;-1:-1:-1;;;;;47703:19:0::3;:39:::0;47677:121:::3;;;::::0;-1:-1:-1;;;47677:121:0;;8974:2:1;47677:121:0::3;::::0;::::3;8956:21:1::0;9013:2;8993:18;;;8986:30;-1:-1:-1;;;9032:18:1;;;9025:50;9092:18;;47677:121:0::3;8772:344:1::0;47677:121:0::3;47657:3:::0;::::3;::::0;::::3;:::i;:::-;;;;47629:181;;;-1:-1:-1::0;47822:16:0::3;:39:::0;;::::3;::::0;::::3;::::0;;;;::::3;::::0;;-1:-1:-1;;;;;;47822:39:0::3;-1:-1:-1::0;;;;;47822:39:0;::::3;::::0;;::::3;::::0;;;-1:-1:-1;47872:31:0;;;:13:::3;47822:39;47872:31:::0;;;;;;;;:47;;;47937:62;;956:25:1;;;47937:62:0::3;::::0;929:18:1;47937:62:0::3;;;;;;;47297:710;47121:886:::0;;:::o;49682:271::-;43387:20;:18;:20::i;:::-;:29;43379:69;;;;-1:-1:-1;;;43379:69:0;;;;;;;:::i;:::-;43541:21:::1;::::0;::::1;;:29;;:21:::0;:29:::1;43519:109;;;;-1:-1:-1::0;;;43519:109:0::1;;;;;;;:::i;:::-;39671:13:::2;:11;:13::i;:::-;-1:-1:-1::0;;;;;49839:21:0;::::3;49831:53;;;::::0;-1:-1:-1;;;49831:53:0;;5550:2:1;49831:53:0::3;::::0;::::3;5532:21:1::0;5589:2;5569:18;;;5562:30;-1:-1:-1;;;5608:18:1;;;5601:49;5667:18;;49831:53:0::3;5348:343:1::0;49831:53:0::3;49895:6;:16:::0;;-1:-1:-1;;;;;;49895:16:0::3;-1:-1:-1::0;;;;;49895:16:0;::::3;::::0;;::::3;::::0;;;49927:18:::3;::::0;::::3;::::0;-1:-1:-1;;49927:18:0::3;49682:271:::0;:::o;44123:1598::-;43247:20;:18;:20::i;:::-;:28;;43271:4;43247:28;43239:69;;;;-1:-1:-1;;;43239:69:0;;9323:2:1;43239:69:0;;;9305:21:1;9362:2;9342:18;;;9335:30;9401;9381:18;;;9374:58;9449:18;;43239:69:0;9121:352:1;43239:69:0;44301:1:::1;44289:9;:13;44281:51;;;::::0;-1:-1:-1;;;44281:51:0;;9680:2:1;44281:51:0::1;::::0;::::1;9662:21:1::0;9719:2;9699:18;;;9692:30;9758:27;9738:18;;;9731:55;9803:18;;44281:51:0::1;9478:349:1::0;44281:51:0::1;44408:10;44379:19;44401:18:::0;;;:6:::1;:18;::::0;;;;44455:15:::1;::::0;;44434:17;;::::1;::::0;:36:::1;44430:85;;44502:1;44487:16:::0;;44430:85:::1;44603:12:::0;;44564:24:::1;::::0;44591::::1;::::0;:9;:24:::1;:::i;:::-;44564:51;;44668:7;44648:16;:27;;44626:109;;;::::0;-1:-1:-1;;;44626:109:0;;10164:2:1;44626:109:0::1;::::0;::::1;10146:21:1::0;;;10183:18;;;10176:30;10242:34;10222:18;;;10215:62;10294:18;;44626:109:0::1;9962:356:1::0;44626:109:0::1;44810:37;::::0;-1:-1:-1;;44827:10:0::1;10500:2:1::0;10496:15;10492:53;44810:37:0::1;::::0;::::1;10480:66:1::0;10562:12;;;10555:28;;;44785:12:0::1;::::0;10599::1;;44810:37:0::1;;;;;;;;;;;;44800:48;;;;;;44785:63;;44881:50;44900:12;;44881:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;44914:10:0::1;::::0;;-1:-1:-1;44926:4:0;;-1:-1:-1;44881:18:0::1;:50::i;:::-;44859:132;;;::::0;-1:-1:-1;;;44859:132:0;;10824:2:1;44859:132:0::1;::::0;::::1;10806:21:1::0;;;10843:18;;;10836:30;10902:34;10882:18;;;10875:62;10954:18;;44859:132:0::1;10622:356:1::0;44859:132:0::1;45057:31:::0;;;45119:15:::1;45099:17;::::0;::::1;:35:::0;45190:6:::1;::::0;45145:63:::1;::::0;-1:-1:-1;;;;;45145:15:0::1;:32:::0;::::1;::::0;45178:10:::1;::::0;45190:6:::1;45198:9:::0;45145:32:::1;:63::i;:::-;45288:16;:23:::0;45271:14:::1;45322:334;45342:6;45338:1;:10;45322:334;;;45370:23;45396:16;45413:1;45396:19;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;::::1;::::0;-1:-1:-1;;;;;45396:19:0::1;::::0;-1:-1:-1;45456:115:0::1;45543:27;45547:23;45543:2;:27;:::i;:::-;-1:-1:-1::0;;;;;45488:31:0;::::1;;::::0;;;:13:::1;:31;::::0;;;;;45456:64:::1;::::0;:9;;:31:::1;:64::i;:::-;:86:::0;::::1;:115::i;:::-;45430:141:::0;-1:-1:-1;45586:58:0::1;-1:-1:-1::0;;;;;45586:29:0;::::1;45616:10;45430:141:::0;45586:29:::1;:58::i;:::-;45355:301;;45350:3;;;;;:::i;:::-;;;;45322:334;;;-1:-1:-1::0;45673:40:0::1;::::0;;3611:25:1;;;3667:2;3652:18;;3645:34;;;45682:10:0::1;::::0;45673:40:::1;::::0;3584:18:1;45673:40:0::1;;;;;;;44270:1451;;;;44123:1598:::0;;;;:::o;49158:287::-;43387:20;:18;:20::i;:::-;:29;43379:69;;;;-1:-1:-1;;;43379:69:0;;;;;;;:::i;:::-;43541:21:::1;::::0;::::1;;:29;;:21:::0;:29:::1;43519:109;;;;-1:-1:-1::0;;;43519:109:0::1;;;;;;;:::i;:::-;39671:13:::2;:11;:13::i;:::-;-1:-1:-1::0;;;;;49319:23:0;::::3;49311:57;;;;-1:-1:-1::0;;;49311:57:0::3;;;;;;;:::i;:::-;49379:8;:20:::0;;-1:-1:-1;;;;;;49379:20:0::3;-1:-1:-1::0;;;;;49379:20:0;::::3;::::0;;::::3;::::0;;;49415:22:::3;::::0;::::3;::::0;-1:-1:-1;;49415:22:0::3;49158:287:::0;:::o;40691:201::-;39671:13;:11;:13::i;:::-;-1:-1:-1;;;;;40780:22:0;::::1;40772:73;;;::::0;-1:-1:-1;;;40772:73:0;;12559:2:1;40772:73:0::1;::::0;::::1;12541:21:1::0;12598:2;12578:18;;;12571:30;12637:34;12617:18;;;12610:62;-1:-1:-1;;;12688:18:1;;;12681:36;12734:19;;40772:73:0::1;12357:402:1::0;40772:73:0::1;40856:28;40875:8;40856:18;:28::i;39950:132::-:0;39831:7;39858:6;-1:-1:-1;;;;;39858:6:0;38416:10;40014:23;40006:68;;;;-1:-1:-1;;;40006:68:0;;12966:2:1;40006:68:0;;;12948:21:1;;;12985:18;;;12978:30;13044:34;13024:18;;;13017:62;13096:18;;40006:68:0;12764:356:1;33867:211:0;34011:58;;-1:-1:-1;;;;;13317:32:1;;34011:58:0;;;13299:51:1;13366:18;;;13359:34;;;33984:86:0;;34004:5;;-1:-1:-1;;;34034:23:0;13272:18:1;;34011:58:0;;;;-1:-1:-1;;34011:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;34011:58:0;-1:-1:-1;;;;;;34011:58:0;;;;;;;;;;33984:19;:86::i;:::-;33867:211;;;:::o;41052:191::-;41126:16;41145:6;;-1:-1:-1;;;;;41162:17:0;;;-1:-1:-1;;;;;;41162:17:0;;;;;;41195:40;;41145:6;;;;;;;41195:40;;41126:16;41195:40;41115:128;41052:191;:::o;3101:190::-;3226:4;3279;3250:25;3263:5;3270:4;3250:12;:25::i;:::-;:33;;3101:190;-1:-1:-1;;;;3101:190:0:o;34086:248::-;34257:68;;-1:-1:-1;;;;;13662:15:1;;;34257:68:0;;;13644:34:1;13714:15;;13694:18;;;13687:43;13746:18;;;13739:34;;;34230:96:0;;34250:5;;-1:-1:-1;;;34280:27:0;13579:18:1;;34257:68:0;13404:375:1;34230:96:0;34086:248;;;;:::o;15054:98::-;15112:7;15139:5;15143:1;15139;:5;:::i;:::-;15132:12;;15054:98;;;;;:::o;15453:::-;15511:7;15538:5;15542:1;15538;:5;:::i;36934:716::-;37358:23;37384:69;37412:4;37384:69;;;;;;;;;;;;;;;;;37392:5;-1:-1:-1;;;;;37384:27:0;;;:69;;;;;:::i;:::-;37468:17;;37358:95;;-1:-1:-1;37468:21:0;37464:179;;37565:10;37554:30;;;;;;;;;;;;:::i;:::-;37546:85;;;;-1:-1:-1;;;37546:85:0;;14663:2:1;37546:85:0;;;14645:21:1;14702:2;14682:18;;;14675:30;14741:34;14721:18;;;14714:62;-1:-1:-1;;;14792:18:1;;;14785:40;14842:19;;37546:85:0;14461:406:1;3968:296:0;4051:7;4094:4;4051:7;4109:118;4133:5;:12;4129:1;:16;4109:118;;;4182:33;4192:12;4206:5;4212:1;4206:8;;;;;;;;:::i;:::-;;;;;;;4182:9;:33::i;:::-;4167:48;-1:-1:-1;4147:3:0;;;;:::i;:::-;;;;4109:118;;;-1:-1:-1;4244:12:0;3968:296;-1:-1:-1;;;3968:296:0:o;22471:229::-;22608:12;22640:52;22662:6;22670:4;22676:1;22679:12;22640:21;:52::i;:::-;22633:59;22471:229;-1:-1:-1;;;;22471:229:0:o;11008:149::-;11071:7;11102:1;11098;:5;:51;;11233:13;11327:15;;;11363:4;11356:15;;;11410:4;11394:21;;11098:51;;;11233:13;11327:15;;;11363:4;11356:15;;;11410:4;11394:21;;11106:20;11165:268;23591:455;23761:12;23819:5;23794:21;:30;;23786:81;;;;-1:-1:-1;;;23786:81:0;;15074:2:1;23786:81:0;;;15056:21:1;15113:2;15093:18;;;15086:30;15152:34;15132:18;;;15125:62;-1:-1:-1;;;15203:18:1;;;15196:36;15249:19;;23786:81:0;14872:402:1;23786:81:0;23879:12;23893:23;23920:6;-1:-1:-1;;;;;23920:11:0;23939:5;23946:4;23920:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23878:73;;;;23969:69;23996:6;24004:7;24013:10;24025:12;23969:26;:69::i;:::-;23962:76;23591:455;-1:-1:-1;;;;;;;23591:455:0:o;26164:644::-;26349:12;26378:7;26374:427;;;26406:10;:17;26427:1;26406:22;26402:290;;-1:-1:-1;;;;;20009:19:0;;;26616:60;;;;-1:-1:-1;;;26616:60:0;;16028:2:1;26616:60:0;;;16010:21:1;16067:2;16047:18;;;16040:30;16106:31;16086:18;;;16079:59;16155:18;;26616:60:0;15826:353:1;26616:60:0;-1:-1:-1;26713:10:0;26706:17;;26374:427;26756:33;26764:10;26776:12;27511:17;;:21;27507:388;;27743:10;27737:17;27800:15;27787:10;27783:2;27779:19;27772:44;27507:388;27870:12;27863:20;;-1:-1:-1;;;27863:20:0;;;;;;;;:::i;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;422:131::-;-1:-1:-1;;;;;497:31:1;;487:42;;477:70;;543:1;540;533:12;558:247;617:6;670:2;658:9;649:7;645:23;641:32;638:52;;;686:1;683;676:12;638:52;725:9;712:23;744:31;769:5;744:31;:::i;:::-;794:5;558:247;-1:-1:-1;;;558:247:1:o;1574:315::-;1642:6;1650;1703:2;1691:9;1682:7;1678:23;1674:32;1671:52;;;1719:1;1716;1709:12;1671:52;1755:9;1742:23;1732:33;;1815:2;1804:9;1800:18;1787:32;1828:31;1853:5;1828:31;:::i;:::-;1878:5;1868:15;;;1574:315;;;;;:::o;2346:330::-;2429:6;2437;2490:2;2478:9;2469:7;2465:23;2461:32;2458:52;;;2506:1;2503;2496:12;2458:52;2545:9;2532:23;2564:31;2589:5;2564:31;:::i;:::-;2614:5;2666:2;2651:18;;;;2638:32;;-1:-1:-1;;;2346:330:1:o;2681:751::-;2785:6;2793;2801;2809;2862:2;2850:9;2841:7;2837:23;2833:32;2830:52;;;2878:1;2875;2868:12;2830:52;2914:9;2901:23;2891:33;;2971:2;2960:9;2956:18;2943:32;2933:42;;3026:2;3015:9;3011:18;2998:32;3049:18;3090:2;3082:6;3079:14;3076:34;;;3106:1;3103;3096:12;3076:34;3144:6;3133:9;3129:22;3119:32;;3189:7;3182:4;3178:2;3174:13;3170:27;3160:55;;3211:1;3208;3201:12;3160:55;3251:2;3238:16;3277:2;3269:6;3266:14;3263:34;;;3293:1;3290;3283:12;3263:34;3346:7;3341:2;3331:6;3328:1;3324:14;3320:2;3316:23;3312:32;3309:45;3306:65;;;3367:1;3364;3357:12;3306:65;2681:751;;;;-1:-1:-1;;3398:2:1;3390:11;;-1:-1:-1;;;2681:751:1:o;3690:345::-;3892:2;3874:21;;;3931:2;3911:18;;;3904:30;-1:-1:-1;;;3965:2:1;3950:18;;3943:51;4026:2;4011:18;;3690:345::o;4040:127::-;4101:10;4096:3;4092:20;4089:1;4082:31;4132:4;4129:1;4122:15;4156:4;4153:1;4146:15;4172:184;4242:6;4295:2;4283:9;4274:7;4270:23;4266:32;4263:52;;;4311:1;4308;4301:12;4263:52;-1:-1:-1;4334:16:1;;4172:184;-1:-1:-1;4172:184:1:o;4361:127::-;4422:10;4417:3;4413:20;4410:1;4403:31;4453:4;4450:1;4443:15;4477:4;4474:1;4467:15;4493:135;4532:3;4553:17;;;4550:43;;4573:18;;:::i;:::-;-1:-1:-1;4620:1:1;4609:13;;4493:135::o;4633:351::-;4835:2;4817:21;;;4874:2;4854:18;;;4847:30;4913:29;4908:2;4893:18;;4886:57;4975:2;4960:18;;4633:351::o;4989:354::-;5191:2;5173:21;;;5230:2;5210:18;;;5203:30;5269:32;5264:2;5249:18;;5242:60;5334:2;5319:18;;4989:354::o;7452:128::-;7519:9;;;7540:11;;;7537:37;;;7554:18;;:::i;7585:127::-;7646:10;7641:3;7637:20;7634:1;7627:31;7677:4;7674:1;7667:15;7701:4;7698:1;7691:15;9832:125;9897:9;;;9918:10;;;9915:36;;;9931:18;;:::i;10983:422::-;11072:1;11115:5;11072:1;11129:270;11150:7;11140:8;11137:21;11129:270;;;11209:4;11205:1;11201:6;11197:17;11191:4;11188:27;11185:53;;;11218:18;;:::i;:::-;11268:7;11258:8;11254:22;11251:55;;;11288:16;;;;11251:55;11367:22;;;;11327:15;;;;11129:270;;;11133:3;10983:422;;;;;:::o;11410:806::-;11459:5;11489:8;11479:80;;-1:-1:-1;11530:1:1;11544:5;;11479:80;11578:4;11568:76;;-1:-1:-1;11615:1:1;11629:5;;11568:76;11660:4;11678:1;11673:59;;;;11746:1;11741:130;;;;11653:218;;11673:59;11703:1;11694:10;;11717:5;;;11741:130;11778:3;11768:8;11765:17;11762:43;;;11785:18;;:::i;:::-;-1:-1:-1;;11841:1:1;11827:16;;11856:5;;11653:218;;11955:2;11945:8;11942:16;11936:3;11930:4;11927:13;11923:36;11917:2;11907:8;11904:16;11899:2;11893:4;11890:12;11886:35;11883:77;11880:159;;;-1:-1:-1;11992:19:1;;;12024:5;;11880:159;12071:34;12096:8;12090:4;12071:34;:::i;:::-;12141:6;12137:1;12133:6;12129:19;12120:7;12117:32;12114:58;;;12152:18;;:::i;:::-;12190:20;;11410:806;-1:-1:-1;;;11410:806:1:o;12221:131::-;12281:5;12310:36;12337:8;12331:4;12310:36;:::i;13784:168::-;13857:9;;;13888;;13905:15;;;13899:22;;13885:37;13875:71;;13926:18;;:::i;13957:217::-;13997:1;14023;14013:132;;14067:10;14062:3;14058:20;14055:1;14048:31;14102:4;14099:1;14092:15;14130:4;14127:1;14120:15;14013:132;-1:-1:-1;14159:9:1;;13957:217::o;14179:277::-;14246:6;14299:2;14287:9;14278:7;14274:23;14270:32;14267:52;;;14315:1;14312;14305:12;14267:52;14347:9;14341:16;14400:5;14393:13;14386:21;14379:5;14376:32;14366:60;;14422:1;14419;14412:12;15279:250;15364:1;15374:113;15388:6;15385:1;15382:13;15374:113;;;15464:11;;;15458:18;15445:11;;;15438:39;15410:2;15403:10;15374:113;;;-1:-1:-1;;15521:1:1;15503:16;;15496:27;15279:250::o;15534:287::-;15663:3;15701:6;15695:13;15717:66;15776:6;15771:3;15764:4;15756:6;15752:17;15717:66;:::i;:::-;15799:16;;;;;15534:287;-1:-1:-1;;15534:287:1:o;16184:396::-;16333:2;16322:9;16315:21;16296:4;16365:6;16359:13;16408:6;16403:2;16392:9;16388:18;16381:34;16424:79;16496:6;16491:2;16480:9;16476:18;16471:2;16463:6;16459:15;16424:79;:::i;:::-;16564:2;16543:15;-1:-1:-1;;16539:29:1;16524:45;;;;16571:2;16520:54;;16184:396;-1:-1:-1;;16184:396:1:o

ipfs://b8828af907f1041dd9b7b3de2deaf85759f7eac50b8a14fcda7d73481eb965ec