Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
•  contract CanyonGenesisRewardPool i ... *
•    - function checkPoolDuplicate(IERC20 _t ...
•    - function add(
•    - function set(uint256 _pid, uint256 _a ...
•    - function getGeneratedReward(uint256 _ ...
•    - function pendingCANYON(uint256 _pid, ...
•    - function massUpdatePools()
•    - function updatePool(uint256 _pid)
•    - function deposit(uint256 _pid, uint25 ...
•    - function withdraw(uint256 _pid, uint2 ...
•    - function emergencyWithdraw(uint256 _p ...
•    - function safeCanyonTransfer(address _ ...
•    - function setFeeAddress(address _feeAd ...
•    - function setOperator(address _operato ...
•    - function governanceRecoverUnsupported ...

More Options

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

/**
 *Submitted for verification at SonicScan.org on 2025-03-01
*/

/**
 *Submitted for verification at testnet.bscscan.com on 2025-03-01
*/

// SPDX-License-Identifier: MIT


// OpenZeppelin Contracts (last updated v4.9.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);
}


// OpenZeppelin Contracts (last updated v4.9.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/[email protected]


// OpenZeppelin Contracts (last updated v4.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/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.8.0/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);
        }
    }
}



// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/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.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
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].
     *
     * CAUTION: See Security Considerations above.
     */
    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/[email protected]


// OpenZeppelin Contracts (last updated v4.9.3) (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;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation 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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}


// OpenZeppelin Contracts (last updated v4.9.0) (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 making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}


// File contracts/distribution/CanyonGenesisRewardPool.sol



pragma solidity ^0.8.0;



// Note that this pool has no minter key of CANYON (rewards).
// Instead, the governance will call CANYON distributeReward method and send reward to this pool at the beginning.
contract CanyonGenesisRewardPool is ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // governance
    address public operator;
    address public feeAddress;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 token; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. CANYON to distribute.
        uint256 lastRewardTime; // Last time that CANYON distribution occurs.
        uint16  depositFeeBP; //depositfee
        uint256 accCanyonPerShare; // Accumulated CANYON per share, times 1e18. See below.
        bool isStarted; // if lastRewardBlock has passed
    }

    IERC20 public canyon;
    address public devFund;

    // Info of each pool.
    PoolInfo[] public poolInfo;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    // The time when CANYON mining starts.
    uint256 public poolStartTime;

    // The time when CANYON mining ends.
    uint256 public poolEndTime;

    // TESTNET
    //uint256 public canyonPerSecond = 0.66667 ether; // 2400 CANYON / (1h * 60min * 60s)
    //uint256 public runningTime = 1 hours; // 1 hours
    //uint256 public constant TOTAL_REWARDS = 2400 ether;
    // END TESTNET

    // MAINNET
    uint256 public canyonPerSecond = 0.138888888 ether; // 12000 CANYON / (24h * 60min * 60s)
    uint256 public runningTime = 1 days; // 1 days
    uint256 public constant TOTAL_REWARDS = 12000 ether;
    // END MAINNET

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event SetFeeAddress(address indexed user, address indexed newAddress);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event RewardPaid(address indexed user, uint256 amount);

    constructor(
        address _canyon,
        address _devFund,
        address _feeAddress,
        uint256 _poolStartTime
    )  {
        require(block.timestamp < _poolStartTime, "late");
        if (_canyon != address(0)) canyon = IERC20(_canyon);
        if (_devFund != address(0)) devFund = _devFund;
        poolStartTime = _poolStartTime;
        poolEndTime = poolStartTime + runningTime;
        operator = msg.sender;
        feeAddress = _feeAddress;
    }

    modifier onlyOperator() {
        require(operator == msg.sender, "CanyonGenesisPool: caller is not the operator");
        _;
    }

    function checkPoolDuplicate(IERC20 _token) internal view {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            require(poolInfo[pid].token != _token, "CanyonGenesisPool: existing pool?");
        }
    }

    // Add a new token to the pool. Can only be called by the owner.
    function add(
        uint256 _allocPoint,
        IERC20 _token,
        bool _withUpdate,
        uint256 _lastRewardTime,
        uint16  _depositFeeBP

    ) public onlyOperator {
            require(_depositFeeBP <= 100, "add: invalid deposit fee basis points");

        checkPoolDuplicate(_token);
        if (_withUpdate) {
            massUpdatePools();
        }
        if (block.timestamp < poolStartTime) {
            // chef is sleeping
            if (_lastRewardTime == 0) {
                _lastRewardTime = poolStartTime;
            } else {
                if (_lastRewardTime < poolStartTime) {
                    _lastRewardTime = poolStartTime;
                }
            }
        } else {
            // chef is cooking
            if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
                _lastRewardTime = block.timestamp;
            }
        }
        bool _isStarted = (_lastRewardTime <= poolStartTime) || (_lastRewardTime <= block.timestamp);
        poolInfo.push(PoolInfo({token: _token, allocPoint: _allocPoint, lastRewardTime: _lastRewardTime, accCanyonPerShare: 0, isStarted: _isStarted, depositFeeBP: _depositFeeBP}));
        if (_isStarted) {
            totalAllocPoint = totalAllocPoint.add(_allocPoint);
        }
    }

    // Update the given pool's CANYON allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint,  uint16 _depositFeeBP) public onlyOperator {
            require(_depositFeeBP <= 100, "set: invalid deposit fee basis points");
        massUpdatePools();
        PoolInfo storage pool = poolInfo[_pid];
        if (pool.isStarted) {
            totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
        }
        pool.allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;

    }

    // Return accumulate rewards over the given _from to _to block.
    function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
        if (_fromTime >= _toTime) return 0;
        if (_toTime >= poolEndTime) {
            if (_fromTime >= poolEndTime) return 0;
            if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(canyonPerSecond);
            return poolEndTime.sub(_fromTime).mul(canyonPerSecond);
        } else {
            if (_toTime <= poolStartTime) return 0;
            if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(canyonPerSecond);
            return _toTime.sub(_fromTime).mul(canyonPerSecond);
        }
    }

    // View function to see pending CANYON on frontend.
    function pendingCANYON(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accCanyonPerShare = pool.accCanyonPerShare;
        uint256 tokenSupply = pool.token.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
            uint256 _canyonReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            accCanyonPerShare = accCanyonPerShare.add(_canyonReward.mul(1e18).div(tokenSupply));
        }
        return user.amount.mul(accCanyonPerShare).div(1e18).sub(user.rewardDebt);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 tokenSupply = pool.token.balanceOf(address(this));
        if (tokenSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        if (!pool.isStarted) {
            pool.isStarted = true;
            totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
        }
        if (totalAllocPoint > 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
            uint256 _canyonReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            pool.accCanyonPerShare = pool.accCanyonPerShare.add(_canyonReward.mul(1e18).div(tokenSupply));
        }
        pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 _pending = user.amount.mul(pool.accCanyonPerShare).div(1e18).sub(user.rewardDebt);
            if (_pending > 0) {
                safeCanyonTransfer(_sender, _pending);
                emit RewardPaid(_sender, _pending);
            }
        }
        if (_amount > 0) {
            pool.token.safeTransferFrom(_sender, address(this), _amount);
            if (address(pool.token) == devFund) {
                user.amount = user.amount.add(_amount.mul(9900).div(10000));
           }
             if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.token.safeTransfer(feeAddress, depositFee);
                // pool.lpToken.safeTransfer(vaultAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
             }
             else {
                user.amount = user.amount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accCanyonPerShare).div(1e18);
        emit Deposit(_sender, _pid, _amount);
    }

    // Withdraw LP tokens.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 _pending = user.amount.mul(pool.accCanyonPerShare).div(1e18).sub(user.rewardDebt);
        if (_pending > 0) {
            safeCanyonTransfer(_sender, _pending);
            emit RewardPaid(_sender, _pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.token.safeTransfer(_sender, _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accCanyonPerShare).div(1e18);
        emit Withdraw(_sender, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 _amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        pool.token.safeTransfer(msg.sender, _amount);
        emit EmergencyWithdraw(msg.sender, _pid, _amount);
    }

    // Safe CANYON transfer function, just in case a rounding error causes pool to not have enough CANYONs.
    function safeCanyonTransfer(address _to, uint256 _amount) internal {
        uint256 _canyonBalance = canyon.balanceOf(address(this));
        if (_canyonBalance > 0) {
            if (_amount > _canyonBalance) {
                canyon.safeTransfer(_to, _canyonBalance);
            } else {
                canyon.safeTransfer(_to, _amount);
            }
        }
    }
    function setFeeAddress(address _feeAddress) external onlyOperator {
        feeAddress = _feeAddress;
        emit SetFeeAddress(msg.sender, _feeAddress);
    }
    function setOperator(address _operator) external onlyOperator {
        operator = _operator;
    }

    function governanceRecoverUnsupported(
        IERC20 _token,
        uint256 amount,
        address to
    ) external onlyOperator {
        if (block.timestamp < poolEndTime + 90 days) {
            // do not allow to drain core token (CANYON or lps) if less than 90 days after pool ends
            require(_token != canyon, "canyon");
            uint256 length = poolInfo.length;
            for (uint256 pid = 0; pid < length; ++pid) {
                PoolInfo storage pool = poolInfo[pid];
                require(_token != pool.token, "pool.token");
            }
        }
        _token.safeTransfer(to, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_canyon","type":"address"},{"internalType":"address","name":"_devFund","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"},{"internalType":"uint256","name":"_poolStartTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"TOTAL_REWARDS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"},{"internalType":"uint256","name":"_lastRewardTime","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"canyon","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canyonPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devFund","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fromTime","type":"uint256"},{"internalType":"uint256","name":"_toTime","type":"uint256"}],"name":"getGeneratedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"governanceRecoverUnsupported","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingCANYON","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"accCanyonPerShare","type":"uint256"},{"internalType":"bool","name":"isStarted","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"runningTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000013f6b9d67b18ec77b124f22cb6e328869c383f2d000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a98000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a980000000000000000000000000000000000000000000000000000000067c34523

-----Decoded View---------------
Arg [0] : _canyon (address): 0x13f6B9d67b18EC77b124F22cB6e328869c383f2d
Arg [1] : _devFund (address): 0xa99fa2707Ec6FE5Ab4b14C88431c40F1FF3B9A98
Arg [2] : _feeAddress (address): 0xa99fa2707Ec6FE5Ab4b14C88431c40F1FF3B9A98
Arg [3] : _poolStartTime (uint256): 1740850467

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000013f6b9d67b18ec77b124f22cb6e328869c383f2d
Arg [1] : 000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a98
Arg [2] : 000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a98
Arg [3] : 0000000000000000000000000000000000000000000000000000000067c34523

33748:12186:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35582:51;;35622:11;35582:51;;;;;160:25:1;;;148:2;133:18;35582:51:0;;;;;;;;34729:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;737:32:1;;;719:51;;801:2;786:18;;779:34;;;;829:18;;;822:34;;;;904:6;892:19;887:2;872:18;;865:47;943:3;928:19;;921:35;1000:14;993:22;757:3;972:19;;965:51;706:3;691:19;34729:26:0;427:595:1;34974:34:0;;;;;;39009:661;;;;;;:::i;:::-;;:::i;38447:485::-;;;;;;:::i;:::-;;:::i;:::-;;33924:25;;;;;-1:-1:-1;;;;;33924:25:0;;;;;;-1:-1:-1;;;;;2129:32:1;;;2111:51;;2099:2;2084:18;33924:25:0;1965:203:1;34671:22:0;;;;;-1:-1:-1;;;;;34671:22:0;;;43228:829;;;;;;:::i;:::-;;:::i;37024:1325::-;;;;;;:::i;:::-;;:::i;40861:916::-;;;;;;:::i;:::-;;:::i;44128:377::-;;;;;;:::i;:::-;;:::i;45287:644::-;;;;;;:::i;:::-;;:::i;33894:23::-;;;;;-1:-1:-1;;;;;33894:23:0;;;35061:28;;;;;;40605:180;;;:::i;35140:26::-;;;;;;45009:163;;;;;;:::i;:::-;;:::i;34813:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4518:25:1;;;4574:2;4559:18;;4552:34;;;;4491:18;34813:64:0;4344:248:1;35530:35:0;;;;;;34644:20;;;;;-1:-1:-1;;;;;34644:20:0;;;45178:101;;;;;;:::i;:::-;;:::i;35435:50::-;;;;;;39735:787;;;;;;:::i;:::-;;:::i;41812:1380::-;;;;;;:::i;:::-;;:::i;34729:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;34729:26:0;;;;-1:-1:-1;34729:26:0;;;;;;;;;;;;:::o;39009:661::-;39094:7;39131;39118:9;:20;39114:34;;-1:-1:-1;39147:1:0;39140:8;;39114:34;39174:11;;39163:7;:22;39159:504;;39219:11;;39206:9;:24;39202:38;;-1:-1:-1;39239:1:0;39232:8;;39202:38;39272:13;;39259:9;:26;39255:90;;39294:51;39329:15;;39294:30;39310:13;;39294:11;;:15;;:30;;;;:::i;:::-;:34;;:51::i;:::-;39287:58;;;;39255:90;39367:47;39398:15;;39367:26;39383:9;39367:11;;:15;;:26;;;;:::i;39159:504::-;39462:13;;39451:7;:24;39447:38;;-1:-1:-1;39484:1:0;39477:8;;39447:38;39517:13;;39504:9;:26;39500:86;;39539:47;39570:15;;39539:26;39551:13;;39539:7;:11;;:26;;;;:::i;39500:86::-;39635:15;;39608:43;;:22;:7;39620:9;39608:11;:22::i;39159:504::-;39009:661;;;;:::o;38447:485::-;36583:8;;-1:-1:-1;;;;;36583:8:0;36595:10;36583:22;36575:80;;;;-1:-1:-1;;;36575:80:0;;;;;;;:::i;:::-;;;;;;;;;38578:3:::1;38561:13;:20;;;;38553:70;;;::::0;-1:-1:-1;;;38553:70:0;;5434:2:1;38553:70:0::1;::::0;::::1;5416:21:1::0;5473:2;5453:18;;;5446:30;5512:34;5492:18;;;5485:62;-1:-1:-1;;;5563:18:1;;;5556:35;5608:19;;38553:70:0::1;5232:401:1::0;38553:70:0::1;38634:17;:15;:17::i;:::-;38662:21;38686:8;38695:4;38686:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;38715;::::0;::::1;::::0;38686;;-1:-1:-1;38715:14:0::1;;38711:118;;;38764:53;38805:11;38764:36;38784:4;:15;;;38764;;:19;;:36;;;;:::i;:::-;:40:::0;::::1;:53::i;:::-;38746:15;:71:::0;38711:118:::1;38857:11;38839:4;:15;;:29;;;;38909:13;38879:8;38888:4;38879:14;;;;;;;;:::i;:::-;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;38538:394;38447:485:::0;;;:::o;43228:829::-;32575:21;:19;:21::i;:::-;43308:15:::1;43326:10;43308:28;;43347:21;43371:8;43380:4;43371:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;43420;;;43371::::1;43420::::0;;;;;;;-1:-1:-1;;;;;43420:23:0;::::1;::::0;;;;;;;;;43462:11;;43371:14;;;::::1;::::0;;::::1;::::0;-1:-1:-1;;;43462:22:0::1;43454:53;;;::::0;-1:-1:-1;;;43454:53:0;;5972:2:1;43454:53:0::1;::::0;::::1;5954:21:1::0;6011:2;5991:18;;;5984:30;-1:-1:-1;;;6030:18:1;;;6023:48;6088:18;;43454:53:0::1;5770:342:1::0;43454:53:0::1;43518:16;43529:4;43518:10;:16::i;:::-;43545;43564:70;43618:4;:15;;;43564:49;43608:4;43564:39;43580:4;:22;;;43564:4;:11;;;:15;;:39;;;;:::i;:::-;:43:::0;::::1;:49::i;:::-;:53:::0;::::1;:70::i;:::-;43545:89:::0;-1:-1:-1;43649:12:0;;43645:131:::1;;43678:37;43697:7;43706:8;43678:18;:37::i;:::-;43746:7;-1:-1:-1::0;;;;;43735:29:0::1;;43755:8;43735:29;;;;160:25:1::0;;148:2;133:18;;14:177;43735:29:0::1;;;;;;;;43645:131;43790:11:::0;;43786:138:::1;;43832:11:::0;;:24:::1;::::0;43848:7;43832:15:::1;:24::i;:::-;43818:38:::0;;43871:10;;:41:::1;::::0;-1:-1:-1;;;;;43871:10:0::1;43895:7:::0;43904;43871:23:::1;:41::i;:::-;43968:22;::::0;::::1;::::0;43952:11;;:49:::1;::::0;43996:4:::1;::::0;43952:39:::1;::::0;:15:::1;:39::i;:49::-;43934:15;::::0;::::1;:67:::0;44017:32:::1;::::0;160:25:1;;;44035:4:0;;-1:-1:-1;;;;;44017:32:0;::::1;::::0;::::1;::::0;148:2:1;133:18;44017:32:0::1;;;;;;;43297:760;;;;32619:20:::0;32013:1;33139:7;:22;32956:213;32619:20;43228:829;;:::o;37024:1325::-;36583:8;;-1:-1:-1;;;;;36583:8:0;36595:10;36583:22;36575:80;;;;-1:-1:-1;;;36575:80:0;;;;;;;:::i;:::-;37253:3:::1;37236:13;:20;;;;37228:70;;;::::0;-1:-1:-1;;;37228:70:0;;6319:2:1;37228:70:0::1;::::0;::::1;6301:21:1::0;6358:2;6338:18;;;6331:30;6397:34;6377:18;;;6370:62;-1:-1:-1;;;6448:18:1;;;6441:35;6493:19;;37228:70:0::1;6117:401:1::0;37228:70:0::1;37311:26;37330:6;37311:18;:26::i;:::-;37352:11;37348:61;;;37380:17;:15;:17::i;:::-;37441:13;;37423:15;:31;37419:534;;;37508:15;37527:1;37508:20:::0;37504:243:::1;;37567:13;;37549:31;;37419:534;;37504:243;37643:13;;37625:15;:31;37621:111;;;37699:13;;37681:31;;37621:111;37419:534;;;37815:20:::0;;;:57:::1;;;37857:15;37839;:33;37815:57;37811:131;;;37911:15;37893:33;;37811:131;37963:15;38001:13;;37982:15;:32;;37981:74;;;;38039:15;38020;:34;;37981:74;38080:157;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;38080:157:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;::::1;::::0;;::::1;::::0;;;;;;-1:-1:-1;38080:157:0;;;;;;;::::1;::::0;::::1;::::0;;;;;;38066:8:::1;:172:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;38066:172:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;38066:172:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;-1:-1:-1;;38066:172:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;38080:157;;-1:-1:-1;38249:93:0::1;;38298:15;::::0;:32:::1;::::0;38318:11;38298:19:::1;:32::i;:::-;38280:15;:50:::0;38249:93:::1;37213:1136;37024:1325:::0;;;;;:::o;40861:916::-;40913:21;40937:8;40946:4;40937:14;;;;;;;;:::i;:::-;;;;;;;;;;;40913:38;;40985:4;:19;;;40966:15;:38;40962:77;;41021:7;40861:916;:::o;40962:77::-;41071:10;;:35;;-1:-1:-1;;;41071:35:0;;41100:4;41071:35;;;2111:51:1;41049:19:0;;-1:-1:-1;;;;;41071:10:0;;:20;;2084:18:1;;41071:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41049:57;;41121:11;41136:1;41121:16;41117:107;;-1:-1:-1;41176:15:0;41154:19;;;;:37;-1:-1:-1;40861:916:0:o;41117:107::-;41239:14;;;;;;41234:138;;41270:14;;;:21;;-1:-1:-1;;41270:21:0;41287:4;41270:21;;;;;;41344:15;;;41324;;:36;;:19;:36::i;:::-;41306:15;:54;41234:138;41386:15;;:19;41382:340;;41422:24;41449:56;41468:4;:19;;;41489:15;41449:18;:56::i;:::-;41422:83;;41520:21;41544:58;41586:15;;41544:37;41565:4;:15;;;41544:16;:20;;:37;;;;:::i;:58::-;41520:82;-1:-1:-1;41642:68:0;41669:40;41697:11;41669:23;41520:82;41687:4;41669:17;:23::i;:40::-;41642:22;;;;;:26;:68::i;:::-;41617:22;;;:93;-1:-1:-1;;41382:340:0;-1:-1:-1;41754:15:0;41732:19;;;;:37;-1:-1:-1;40861:916:0:o;44128:377::-;44187:21;44211:8;44220:4;44211:14;;;;;;;;:::i;:::-;;;;;;;;;44260;;;44211;44260;;;;;;;44275:10;44260:26;;;;;;;44315:11;;44337:15;;;-1:-1:-1;44363:15:0;;:19;;;;44211:14;;;44393:10;;44211:14;;-1:-1:-1;44260:26:0;;44315:11;44393:44;;-1:-1:-1;;;;;44393:10:0;;;;44315:11;44393:23;:44::i;:::-;44453;;160:25:1;;;44483:4:0;;44471:10;;44453:44;;148:2:1;133:18;44453:44:0;;;;;;;44176:329;;;44128:377;:::o;45287:644::-;36583:8;;-1:-1:-1;;;;;36583:8:0;36595:10;36583:22;36575:80;;;;-1:-1:-1;;;36575:80:0;;;;;;;:::i;:::-;45457:11:::1;::::0;:21:::1;::::0;45471:7:::1;45457:21;:::i;:::-;45439:15;:39;45435:447;;;45615:6;::::0;-1:-1:-1;;;;;45615:6:0;;::::1;45605:16:::0;;::::1;::::0;45597:35:::1;;;::::0;-1:-1:-1;;;45597:35:0;;7176:2:1;45597:35:0::1;::::0;::::1;7158:21:1::0;7215:1;7195:18;;;7188:29;-1:-1:-1;;;7233:18:1;;;7226:36;7279:18;;45597:35:0::1;6974:329:1::0;45597:35:0::1;45664:8;:15:::0;45647:14:::1;45694:177;45722:6;45716:3;:12;45694:177;;;45756:21;45780:8;45789:3;45780:13;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;45830:10:::0;;45780:13;;-1:-1:-1;;;;;;45830:10:0;;::::1;45820:20:::0;;::::1;::::0;45812:43:::1;;;::::0;-1:-1:-1;;;45812:43:0;;7510:2:1;45812:43:0::1;::::0;::::1;7492:21:1::0;7549:2;7529:18;;;7522:30;-1:-1:-1;;;7568:18:1;;;7561:40;7618:18;;45812:43:0::1;7308:334:1::0;45812:43:0::1;-1:-1:-1::0;45730:5:0::1;;45694:177;;;;45480:402;45435:447;45892:31;-1:-1:-1::0;;;;;45892:19:0;::::1;45912:2:::0;45916:6;45892:19:::1;:31::i;:::-;45287:644:::0;;;:::o;40605:180::-;40667:8;:15;40650:14;40693:85;40721:6;40715:3;:12;40693:85;;;40751:15;40762:3;40751:10;:15::i;:::-;40729:5;;40693:85;;45009:163;36583:8;;-1:-1:-1;;;;;36583:8:0;36595:10;36583:22;36575:80;;;;-1:-1:-1;;;36575:80:0;;;;;;;:::i;:::-;45086:10:::1;:24:::0;;-1:-1:-1;;;;;;45086:24:0::1;-1:-1:-1::0;;;;;45086:24:0;::::1;::::0;;::::1;::::0;;;45126:38:::1;::::0;45140:10:::1;::::0;45126:38:::1;::::0;-1:-1:-1;;45126:38:0::1;45009:163:::0;:::o;45178:101::-;36583:8;;-1:-1:-1;;;;;36583:8:0;36595:10;36583:22;36575:80;;;;-1:-1:-1;;;36575:80:0;;;;;;;:::i;:::-;45251:8:::1;:20:::0;;-1:-1:-1;;;;;;45251:20:0::1;-1:-1:-1::0;;;;;45251:20:0;;;::::1;::::0;;;::::1;::::0;;45178:101::o;39735:787::-;39810:7;39830:21;39854:8;39863:4;39854:14;;;;;;;;:::i;:::-;;;;;;;;;39903;;;39854;39903;;;;;;;-1:-1:-1;;;;;39903:21:0;;;;;;;;;;39854:14;;;;;;;39963:22;;;;;40018:10;;:35;;-1:-1:-1;;;40018:35:0;;40047:4;40018:35;;;2111:51:1;;;;39854:14:0;;-1:-1:-1;39903:21:0;;39963:22;;39854:14;;40018:10;;;;;:20;;2084:18:1;;40018:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;39996:57;;40086:4;:19;;;40068:15;:37;:57;;;;-1:-1:-1;40109:16:0;;;40068:57;40064:368;;;40142:24;40169:56;40188:4;:19;;;40209:15;40169:18;:56::i;:::-;40142:83;;40240:21;40264:58;40306:15;;40264:37;40285:4;:15;;;40264:16;:20;;:37;;;;:::i;:58::-;40240:82;-1:-1:-1;40357:63:0;40379:40;40407:11;40379:23;40240:82;40397:4;40379:17;:23::i;:40::-;40357:17;;:21;:63::i;:::-;40337:83;;40127:305;;40064:368;40449:65;40498:4;:15;;;40449:44;40488:4;40449:34;40465:17;40449:4;:11;;;:15;;:34;;;;:::i;:65::-;40442:72;39735:787;-1:-1:-1;;;;;;;39735:787:0:o;41812:1380::-;32575:21;:19;:21::i;:::-;41891:15:::1;41909:10;41891:28;;41930:21;41954:8;41963:4;41954:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;42003;;;41954::::1;42003::::0;;;;;;;-1:-1:-1;;;;;42003:23:0;::::1;::::0;;;;;;;;;41954:14;::::1;::::0;;::::1;::::0;-1:-1:-1;42037:16:0::1;42012:4:::0;42037:10:::1;:16::i;:::-;42068:11:::0;;:15;42064:294:::1;;42100:16;42119:70;42173:4;:15;;;42119:49;42163:4;42119:39;42135:4;:22;;;42119:4;:11;;;:15;;:39;;;;:::i;:70::-;42100:89:::0;-1:-1:-1;42208:12:0;;42204:143:::1;;42241:37;42260:7;42269:8;42241:18;:37::i;:::-;42313:7;-1:-1:-1::0;;;;;42302:29:0::1;;42322:8;42302:29;;;;160:25:1::0;;148:2;133:18;;14:177;42302:29:0::1;;;;;;;;42204:143;42085:273;42064:294;42372:11:::0;;42368:692:::1;;42400:10:::0;;:60:::1;::::0;-1:-1:-1;;;;;42400:10:0::1;42428:7:::0;42445:4:::1;42452:7:::0;42400:27:::1;:60::i;:::-;42502:7;::::0;42487:10;;-1:-1:-1;;;;;42502:7:0;;::::1;42487:10:::0;::::1;42479:30:::0;42475:129:::1;;42544:45;42560:28;42582:5;42560:17;:7:::0;42572:4:::1;42560:11;:17::i;:28::-;42544:11:::0;;;:15:::1;:45::i;:::-;42530:59:::0;;42475:129:::1;42623:17;::::0;::::1;::::0;::::1;;:21:::0;42619:430:::1;;42698:17;::::0;::::1;::::0;42665:18:::1;::::0;42686:41:::1;::::0;42721:5:::1;::::0;42686:30:::1;::::0;:7;;42698:17:::1;;42686:11;:30::i;:41::-;42770:10;::::0;42746;;42665:62;;-1:-1:-1;42746:47:0::1;::::0;-1:-1:-1;;;;;42746:10:0;;::::1;::::0;42770::::1;42665:62:::0;42746:23:::1;:47::i;:::-;42899:11:::0;;:40:::1;::::0;42928:10;;42899:24:::1;::::0;42915:7;42899:15:::1;:24::i;:40::-;42885:54:::0;;-1:-1:-1;42619:430:0::1;;;43009:11:::0;;:24:::1;::::0;43025:7;43009:15:::1;:24::i;:::-;42995:38:::0;;42619:430:::1;43104:22;::::0;::::1;::::0;43088:11;;:49:::1;::::0;43132:4:::1;::::0;43088:39:::1;::::0;:15:::1;:39::i;:49::-;43070:15;::::0;::::1;:67:::0;43153:31:::1;::::0;160:25:1;;;43170:4:0;;-1:-1:-1;;;;;43153:31:0;::::1;::::0;::::1;::::0;148:2:1;133:18;43153:31:0::1;;;;;;;41880:1312;;;32619:20:::0;32013:1;33139:7;:22;32956:213;6096:98;6154:7;6181:5;6185:1;6181;:5;:::i;:::-;6174:12;6096:98;-1:-1:-1;;;6096:98:0:o;6453:::-;6511:7;6538:5;6542:1;6538;:5;:::i;5715:98::-;5773:7;5800:5;5804:1;5800;:5;:::i;32655:293::-;32057:1;32789:7;;:19;32781:63;;;;-1:-1:-1;;;32781:63:0;;8155:2:1;32781:63:0;;;8137:21:1;8194:2;8174:18;;;8167:30;8233:33;8213:18;;;8206:61;8284:18;;32781:63:0;7953:355:1;32781:63:0;32057:1;32922:7;:18;32655:293::o;6852:98::-;6910:7;6937:5;6941:1;6937;:5;:::i;44622:381::-;44725:6;;:31;;-1:-1:-1;;;44725:31:0;;44750:4;44725:31;;;2111:51:1;44700:22:0;;-1:-1:-1;;;;;44725:6:0;;:16;;2084:18:1;;44725:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44700:56;-1:-1:-1;44771:18:0;;44767:229;;44820:14;44810:7;:24;44806:179;;;44855:6;;:40;;-1:-1:-1;;;;;44855:6:0;44875:3;44880:14;44855:19;:40::i;44806:179::-;44936:6;;:33;;-1:-1:-1;;;;;44936:6:0;44956:3;44961:7;24180:177;24290:58;;-1:-1:-1;;;;;8727:32:1;;24290:58:0;;;8709:51:1;8776:18;;;8769:34;;;24263:86:0;;24283:5;;-1:-1:-1;;;24313:23:0;8682:18:1;;24290:58:0;;;;-1:-1:-1;;24290:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;24290:58:0;-1:-1:-1;;;;;;24290:58:0;;;;;;;;;;24263:19;:86::i;36683:263::-;36768:8;:15;36751:14;36794:145;36822:6;36816:3;:12;36794:145;;;36883:6;-1:-1:-1;;;;;36860:29:0;:8;36869:3;36860:13;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:19;-1:-1:-1;;;;;36860:19:0;:29;36852:75;;;;-1:-1:-1;;;36852:75:0;;9016:2:1;36852:75:0;;;8998:21:1;9055:2;9035:18;;;9028:30;9094:34;9074:18;;;9067:62;-1:-1:-1;;;9145:18:1;;;9138:31;9186:19;;36852:75:0;8814:397:1;36852:75:0;36830:5;;36794:145;;24602:205;24730:68;;-1:-1:-1;;;;;9436:32:1;;;24730:68:0;;;9418:51:1;9505:32;;9485:18;;;9478:60;9554:18;;;9547:34;;;24703:96:0;;24723:5;;-1:-1:-1;;;24753:27:0;9391:18:1;;24730:68:0;9216:371:1;24703:96:0;24602:205;;;;:::o;28526:649::-;28950:23;28976:69;29004:4;28976:69;;;;;;;;;;;;;;;;;28984:5;-1:-1:-1;;;;;28976:27:0;;;:69;;;;;:::i;:::-;28950:95;;29064:10;:17;29085:1;29064:22;:56;;;;29101:10;29090:30;;;;;;;;;;;;:::i;:::-;29056:111;;;;-1:-1:-1;;;29056:111:0;;10044:2:1;29056:111:0;;;10026:21:1;10083:2;10063:18;;;10056:30;10122:34;10102:18;;;10095:62;-1:-1:-1;;;10173:18:1;;;10166:40;10223:19;;29056:111:0;9842:406:1;14013:229:0;14150:12;14182:52;14204:6;14212:4;14218:1;14221:12;14182:21;:52::i;:::-;14175:59;14013:229;-1:-1:-1;;;;14013:229:0:o;15099:455::-;15269:12;15327:5;15302:21;:30;;15294:81;;;;-1:-1:-1;;;15294:81:0;;10455:2:1;15294:81:0;;;10437:21:1;10494:2;10474:18;;;10467:30;10533:34;10513:18;;;10506:62;-1:-1:-1;;;10584:18:1;;;10577:36;10630:19;;15294:81:0;10253:402:1;15294:81:0;15387:12;15401:23;15428:6;-1:-1:-1;;;;;15428:11:0;15447:5;15454:4;15428:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15386:73;;;;15477:69;15504:6;15512:7;15521:10;15533:12;17857;17886:7;17882:427;;;17914:10;:17;17935:1;17914:22;17910:290;;-1:-1:-1;;;;;11553:19:0;;;18124:60;;;;-1:-1:-1;;;18124:60:0;;11168:2:1;18124:60:0;;;11150:21:1;11207:2;11187:18;;;11180:30;11246:31;11226:18;;;11219:59;11295:18;;18124:60:0;10966:353:1;18124:60:0;-1:-1:-1;18221:10:0;18214:17;;17882:427;18264:33;18272:10;18284:12;19019:17;;:21;19015:388;;19251:10;19245:17;19308:15;19295:10;19291:2;19287:19;19280:44;19015:388;19378:12;19371:20;;-1:-1:-1;;;19371:20:0;;;;;;;;:::i;196:226:1:-;255:6;308:2;296:9;287:7;283:23;279:32;276:52;;;324:1;321;314:12;276:52;-1:-1:-1;369:23:1;;196:226;-1:-1:-1;196:226:1:o;1027:346::-;1095:6;1103;1156:2;1144:9;1135:7;1131:23;1127:32;1124:52;;;1172:1;1169;1162:12;1124:52;-1:-1:-1;;1217:23:1;;;1337:2;1322:18;;;1309:32;;-1:-1:-1;1027:346:1:o;1378:159::-;1445:20;;1505:6;1494:18;;1484:29;;1474:57;;1527:1;1524;1517:12;1474:57;1378:159;;;:::o;1542:418::-;1618:6;1626;1634;1687:2;1675:9;1666:7;1662:23;1658:32;1655:52;;;1703:1;1700;1693:12;1655:52;1748:23;;;-1:-1:-1;1868:2:1;1853:18;;1840:32;;-1:-1:-1;1917:37:1;1950:2;1935:18;;1917:37;:::i;:::-;1907:47;;1542:418;;;;;:::o;2173:139::-;-1:-1:-1;;;;;2256:31:1;;2246:42;;2236:70;;2302:1;2299;2292:12;2236:70;2173:139;:::o;2317:118::-;2403:5;2396:13;2389:21;2382:5;2379:32;2369:60;;2425:1;2422;2415:12;2440:717;2544:6;2552;2560;2568;2576;2629:3;2617:9;2608:7;2604:23;2600:33;2597:53;;;2646:1;2643;2636:12;2597:53;2691:23;;;-1:-1:-1;2790:2:1;2775:18;;2762:32;2803:41;2762:32;2803:41;:::i;:::-;2863:7;-1:-1:-1;2922:2:1;2907:18;;2894:32;2935:30;2894:32;2935:30;:::i;:::-;2984:7;-1:-1:-1;3064:2:1;3049:18;;3036:32;;-1:-1:-1;3113:38:1;3146:3;3131:19;;3113:38;:::i;:::-;3103:48;;2440:717;;;;;;;;:::o;3162:537::-;3252:6;3260;3268;3321:2;3309:9;3300:7;3296:23;3292:32;3289:52;;;3337:1;3334;3327:12;3289:52;3376:9;3363:23;3395:39;3428:5;3395:39;:::i;:::-;3453:5;-1:-1:-1;3531:2:1;3516:18;;3503:32;;-1:-1:-1;3613:2:1;3598:18;;3585:32;3626:41;3585:32;3626:41;:::i;:::-;3686:7;3676:17;;;3162:537;;;;;:::o;3704:255::-;3763:6;3816:2;3804:9;3795:7;3791:23;3787:32;3784:52;;;3832:1;3829;3822:12;3784:52;3871:9;3858:23;3890:39;3923:5;3890:39;:::i;3964:375::-;4032:6;4040;4093:2;4081:9;4072:7;4068:23;4064:32;4061:52;;;4109:1;4106;4099:12;4061:52;4154:23;;;-1:-1:-1;4253:2:1;4238:18;;4225:32;4266:41;4225:32;4266:41;:::i;:::-;4326:7;4316:17;;;3964:375;;;;;:::o;4818:409::-;5020:2;5002:21;;;5059:2;5039:18;;;5032:30;5098:34;5093:2;5078:18;;5071:62;-1:-1:-1;;;5164:2:1;5149:18;;5142:43;5217:3;5202:19;;4818:409::o;5638:127::-;5699:10;5694:3;5690:20;5687:1;5680:31;5730:4;5727:1;5720:15;5754:4;5751:1;5744:15;6523:184;6593:6;6646:2;6634:9;6625:7;6621:23;6617:32;6614:52;;;6662:1;6659;6652:12;6614:52;-1:-1:-1;6685:16:1;;6523:184;-1:-1:-1;6523:184:1:o;6712:127::-;6773:10;6768:3;6764:20;6761:1;6754:31;6804:4;6801:1;6794:15;6828:4;6825:1;6818:15;6844:125;6909:9;;;6930:10;;;6927:36;;;6943:18;;:::i;7647:128::-;7714:9;;;7735:11;;;7732:37;;;7749:18;;:::i;7780:168::-;7853:9;;;7884;;7901:15;;;7895:22;;7881:37;7871:71;;7922:18;;:::i;8313:217::-;8353:1;8379;8369:132;;8423:10;8418:3;8414:20;8411:1;8404:31;8458:4;8455:1;8448:15;8486:4;8483:1;8476:15;8369:132;-1:-1:-1;8515:9:1;;8313:217::o;9592:245::-;9659:6;9712:2;9700:9;9691:7;9687:23;9683:32;9680:52;;;9728:1;9725;9718:12;9680:52;9760:9;9754:16;9779:28;9801:5;9779:28;:::i;10660:301::-;10789:3;10827:6;10821:13;10873:6;10866:4;10858:6;10854:17;10849:3;10843:37;10935:1;10899:16;;10924:13;;;-1:-1:-1;10899:16:1;10660:301;-1:-1:-1;10660:301:1:o;11324:418::-;11473:2;11462:9;11455:21;11436:4;11505:6;11499:13;11548:6;11543:2;11532:9;11528:18;11521:34;11607:6;11602:2;11594:6;11590:15;11585:2;11574:9;11570:18;11564:50;11663:1;11658:2;11649:6;11638:9;11634:22;11630:31;11623:42;11733:2;11726;11722:7;11717:2;11709:6;11705:15;11701:29;11690:9;11686:45;11682:54;11674:62;;;11324:418;;;;:::o

ipfs://cde887a0a383cb382aae32f0a1621e466d6106a00a7f0ea5e2f4eac8546b2747