Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library MathUtil
•    - function min(uint256 a, uint256 b)
•  contract ReentrancyGuard
• interface ICurveGauge
•    - function deposit(uint256)
•    - function balanceOf(address)
•    - function withdraw(uint256)
•    - function claim_rewards()
•    - function reward_tokens(uint256)
•    - function rewarded_token()
• interface ICurveVoteEscrow
•    - function create_lock(uint256, uint256 ...
•    - function increase_amount(uint256)
•    - function increase_unlock_time(uint256 ...
•    - function withdraw()
•    - function smart_wallet_checker()
• interface IWalletChecker
•    - function check(address)
• interface IVoting
•    - function vote(uint256, bool, bool)
•    - function getVote(uint256)
•    - function vote_for_gauge_weights(addre ...
• interface IMinter
•    - function mint(address)
• interface IRegistry
•    - function get_registry()
•    - function get_address(uint256 _id)
•    - function gauge_controller()
•    - function get_lp_token(address)
•    - function get_gauges(address)
• interface IStaker
•    - function deposit(address, address)
•    - function withdraw(address)
•    - function withdraw(address, address, u ...
•    - function withdrawAll(address, address ...
•    - function createLock(uint256, uint256)
•    - function increaseAmount(uint256)
•    - function increaseTime(uint256)
•    - function release()
•    - function claimCrv(address)
•    - function claimRewards(address)
•    - function claimFees(address,address)
•    - function setStashAccess(address, bool ...
•    - function vote(uint256,address,bool)
•    - function voteGaugeWeight(address,uint ...
•    - function balanceOfPool(address)
•    - function operator()
•    - function execute(address _to, uint256 ...
• interface IRewards
•    - function stake(address, uint256)
•    - function stakeFor(address, uint256)
•    - function withdraw(address, uint256)
•    - function exit(address)
•    - function getReward(address)
•    - function queueNewRewards(uint256)
•    - function notifyRewardAmount(uint256)
•    - function addExtraReward(address)
•    - function stakingToken()
• interface IStash
•    - function stashRewards()
•    - function processStash()
•    - function claimRewards()
• interface IFeeDistro
•    - function claim()
•    - function token()
• interface ITokenMinter
•    - function mint(address,uint256)
•    - function burn(address,uint256)
• interface IDeposit
•    - function isShutdown()
•    - function balanceOf(address _account)
•    - function totalSupply()
•    - function poolInfo(uint256)
•    - function rewardClaimed(uint256,addres ...
•    - function withdrawTo(uint256,uint256,a ...
•    - function claimRewards(uint256,address ...
•    - function rewardArbitrator()
• interface ICrvDeposit
•    - function deposit(uint256, bool)
•    - function lockIncentive()
• interface IRewardFactory
•    - function setAccess(address,bool)
•    - function CreateCrvRewards(uint256,add ...
•    - function CreateTokenRewards(address,a ...
•    - function activeRewardCount(address)
•    - function addActiveReward(address,uint ...
•    - function removeActiveReward(address,u ...
• interface IStashFactory
•    - function CreateStash(uint256,address, ...
• interface ITokenFactory
•    - function CreateDepositToken(address)
• interface IPools
•    - function addPool(address _lptoken, ad ...
•    - function shutdownPool(uint256 _pid)
•    - function poolInfo(uint256)
•    - function poolLength()
•    - function gaugeMap(address)
•    - function setPoolManager(address _pool ...
• interface IVestedEscrow
•    - function fund(address[] calldata _rec ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• 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 SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
•  contract MerkleAirdrop *
•    - function setOwner(address _owner)
•    - function setRewardContract(address _r ...
•    - function setRewardToken(address _rewa ...
•    - function setMintToken(address _mintTo ...
•    - function setRoot(bytes32 _merkleRoot)
•    - function addressToAsciiString(address ...
•    - function char(byte b)
•    - function uintToStr(uint _i)
•    - function getLeaf(address _a, uint256 ...
•    - function claim(bytes32[] calldata _pr ...
•    - function checkProof(bytes32[] calldat ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-05-18
*/

// SPDX-License-Identifier: MIT

// File: contracts\Interfaces.sol

pragma solidity 0.6.12;


/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library MathUtil {
    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

contract ReentrancyGuard {
    uint256 private _guardCounter;

    constructor () internal {
        _guardCounter = 1;
    }

    modifier nonReentrant() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
    }
}

interface ICurveGauge {
    function deposit(uint256) external;
    function balanceOf(address) external view returns (uint256);
    function withdraw(uint256) external;
    function claim_rewards() external;
    function reward_tokens(uint256) external view returns(address);//v2
    function rewarded_token() external view returns(address);//v1
}

interface ICurveVoteEscrow {
    function create_lock(uint256, uint256) external;
    function increase_amount(uint256) external;
    function increase_unlock_time(uint256) external;
    function withdraw() external;
    function smart_wallet_checker() external view returns (address);
}

interface IWalletChecker {
    function check(address) external view returns (bool);
}

interface IVoting{
    function vote(uint256, bool, bool) external; //voteId, support, executeIfDecided
    function getVote(uint256) external view returns(bool,bool,uint64,uint64,uint64,uint64,uint256,uint256,uint256,bytes memory); 
    function vote_for_gauge_weights(address,uint256) external;
}

interface IMinter{
    function mint(address) external;
}

interface IRegistry{
    function get_registry() external view returns(address);
    function get_address(uint256 _id) external view returns(address);
    function gauge_controller() external view returns(address);
    function get_lp_token(address) external view returns(address);
    function get_gauges(address) external view returns(address[10] memory,uint128[10] memory);
}

interface IStaker{
    function deposit(address, address) external;
    function withdraw(address) external;
    function withdraw(address, address, uint256) external;
    function withdrawAll(address, address) external;
    function createLock(uint256, uint256) external;
    function increaseAmount(uint256) external;
    function increaseTime(uint256) external;
    function release() external;
    function claimCrv(address) external returns (uint256);
    function claimRewards(address) external;
    function claimFees(address,address) external;
    function setStashAccess(address, bool) external;
    function vote(uint256,address,bool) external;
    function voteGaugeWeight(address,uint256) external;
    function balanceOfPool(address) external view returns (uint256);
    function operator() external view returns (address);
    function execute(address _to, uint256 _value, bytes calldata _data) external returns (bool, bytes memory);
}

interface IRewards{
    function stake(address, uint256) external;
    function stakeFor(address, uint256) external;
    function withdraw(address, uint256) external;
    function exit(address) external;
    function getReward(address) external;
    function queueNewRewards(uint256) external;
    function notifyRewardAmount(uint256) external;
    function addExtraReward(address) external;
    function stakingToken() external returns (address);
}

interface IStash{
    function stashRewards() external returns (bool);
    function processStash() external returns (bool);
    function claimRewards() external returns (bool);
}

interface IFeeDistro{
    function claim() external;
    function token() external view returns(address);
}

interface ITokenMinter{
    function mint(address,uint256) external;
    function burn(address,uint256) external;
}

interface IDeposit{
    function isShutdown() external view returns(bool);
    function balanceOf(address _account) external view returns(uint256);
    function totalSupply() external view returns(uint256);
    function poolInfo(uint256) external view returns(address,address,address,address,address, bool);
    function rewardClaimed(uint256,address,uint256) external;
    function withdrawTo(uint256,uint256,address) external;
    function claimRewards(uint256,address) external returns(bool);
    function rewardArbitrator() external returns(address);
}

interface ICrvDeposit{
    function deposit(uint256, bool) external;
    function lockIncentive() external view returns(uint256);
}

interface IRewardFactory{
    function setAccess(address,bool) external;
    function CreateCrvRewards(uint256,address) external returns(address);
    function CreateTokenRewards(address,address,address) external returns(address);
    function activeRewardCount(address) external view returns(uint256);
    function addActiveReward(address,uint256) external returns(bool);
    function removeActiveReward(address,uint256) external returns(bool);
}

interface IStashFactory{
    function CreateStash(uint256,address,address,uint256) external returns(address);
}

interface ITokenFactory{
    function CreateDepositToken(address) external returns(address);
}

interface IPools{
    function addPool(address _lptoken, address _gauge, uint256 _stashVersion) external returns(bool);
    function shutdownPool(uint256 _pid) external returns(bool);
    function poolInfo(uint256) external view returns(address,address,address,address,address,bool);
    function poolLength() external view returns (uint256);
    function gaugeMap(address) external view returns(bool);
    function setPoolManager(address _poolM) external;
}

interface IVestedEscrow{
    function fund(address[] calldata _recipient, uint256[] calldata _amount) external returns(bool);
}

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

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin\contracts\utils\Address.sol

pragma solidity >=0.6.2 <0.8.0;

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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File: node_modules\@openzeppelin\contracts\math\SafeMath.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
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) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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) {
        // 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) {
        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) {
        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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @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. 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) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


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

pragma solidity >=0.6.0 <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 SafeMath for uint256;
    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'
        // solhint-disable-next-line max-line-length
        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).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

    /**
     * @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
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: contracts\MerkleAirdrop.sol
/**
 * Copyright (C) 2018  Smartz, LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND (express or implied).
 */
/*
Changes by Convex
- update to solidity 0.6.12
- allow different types of claiming(transfer, mint, generic interaction with seperate contract)
*/

pragma solidity 0.6.12;



contract MerkleAirdrop {
    using SafeERC20 for IERC20;
    using Address for address;

    address public owner;
    bytes32 public merkleRoot;

    address public rewardContract;
    address public rewardToken;
    address public mintToken;

    mapping (address => bool) public hasClaimed;
    event Claim(address addr, uint256 num);

    constructor(address _owner) public {
        owner = _owner;
    }

    function setOwner(address _owner) external {
        require(msg.sender == owner);
        owner = _owner;
    }

    function setRewardContract(address _rewardContract) external {
        require(msg.sender == owner);
        rewardContract = _rewardContract;
    }

    function setRewardToken(address _rewardToken) external {
        require(msg.sender == owner);
        rewardToken = _rewardToken;
    }

    function setMintToken(address _mintToken) external {
        require(msg.sender == owner);
        mintToken = _mintToken;
    }

    function setRoot(bytes32 _merkleRoot) external {
        require(msg.sender == owner);
        merkleRoot = _merkleRoot;
    }

    function addressToAsciiString(address x) internal pure returns (string memory) {
        bytes memory s = new bytes(40);
        for (uint i = 0; i < 20; i++) {
            byte b = byte(uint8(uint(x) / (2**(8*(19 - i)))));
            byte hi = byte(uint8(b) / 16);
            byte lo = byte(uint8(b) - 16 * uint8(hi));
            s[2*i] = char(hi);
            s[2*i+1] = char(lo);
        }
        return string(s);
    }

    function char(byte b) internal pure returns (byte c) {
        if (uint8(b) < 10) return byte(uint8(b) + 0x30);
        else return byte(uint8(b) + 0x57);
    }

    function uintToStr(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len;
        while (_i != 0) {
            k = k-1;
            uint8 temp = (48 + uint8(_i - _i / 10 * 10));
            bytes1 b1 = bytes1(temp);
            bstr[k] = b1;
            _i /= 10;
        }
        return string(bstr);
    }

    function getLeaf(address _a, uint256 _n) internal pure returns(bytes32) {
        string memory prefix = "0x";
        string memory space = " ";

        return keccak256(abi.encodePacked(prefix,addressToAsciiString(_a),space,uintToStr(_n)));
    }


    function claim(bytes32[] calldata _proof, address _who, uint256 _amount) public returns(bool) {
        require(hasClaimed[_who] != true,"already claimed");
        require(_amount > 0);
        require(checkProof(_proof, getLeaf(_who, _amount)),"failed proof check");

        hasClaimed[_who] = true;

        if(rewardToken != address(0)){
            //send reward token directly
            IERC20(rewardToken).safeTransfer(_who, _amount);
        }else if(mintToken != address(0)){
            //mint tokens directly
            ITokenMinter(mintToken).mint(_who, _amount);
        }else{
            //inform a different reward contract that a claim has been made
            address[] memory recip = new address[](1);
            recip[0] = _who;
            uint256[] memory amounts = new uint256[](1);
            amounts[0] = _amount;
            IVestedEscrow(rewardContract).fund(recip,amounts);
        }

        emit Claim(_who, _amount);
        return true;
    }

    function checkProof(bytes32[] calldata _proof, bytes32 _hash) view internal returns (bool) {
        bytes32 el;
        bytes32 h = _hash;

        for (uint i = 0; i <= _proof.length - 1; i += 1) {
            el = _proof[i];

            if (h < el) {
                h = keccak256(abi.encodePacked(h, el));
            } else {
                h = keccak256(abi.encodePacked(el, h));
            }
        }

        return h == merkleRoot;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"num","type":"uint256"}],"name":"Claim","type":"event"},{"inputs":[{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"},{"internalType":"address","name":"_who","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"claim","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasClaimed","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":"mintToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_mintToken","type":"address"}],"name":"setMintToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardContract","type":"address"}],"name":"setRewardContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"name":"setRewardToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

28749:4081:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29182:115;;;;;;;;;;;;;;;;-1:-1:-1;29182:115:0;-1:-1:-1;;;;;29182:115:0;;:::i;:::-;;28976:24;;;:::i;:::-;;;;-1:-1:-1;;;;;28976:24:0;;;;;;;;;;;;;;28873:25;;;:::i;:::-;;;;;;;;;;;;;;;;29611:131;;;;;;;;;;;;;;;;-1:-1:-1;29611:131:0;-1:-1:-1;;;;;29611:131:0;;:::i;29305:151::-;;;;;;;;;;;;;;;;-1:-1:-1;29305:151:0;-1:-1:-1;;;;;29305:151:0;;:::i;28907:29::-;;;:::i;29009:43::-;;;;;;;;;;;;;;;;-1:-1:-1;29009:43:0;-1:-1:-1;;;;;29009:43:0;;:::i;:::-;;;;;;;;;;;;;;;;;;29464:139;;;;;;;;;;;;;;;;-1:-1:-1;29464:139:0;-1:-1:-1;;;;;29464:139:0;;:::i;28846:20::-;;;:::i;31349:1005::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31349:1005:0;-1:-1:-1;;;;;;31349:1005:0;;;;;;;;:::i;29750:129::-;;;;;;;;;;;;;;;;-1:-1:-1;29750:129:0;;:::i;28943:26::-;;;:::i;29182:115::-;29258:5;;-1:-1:-1;;;;;29258:5:0;29244:10;:19;29236:28;;;;;;29275:5;:14;;-1:-1:-1;;;;;;29275:14:0;-1:-1:-1;;;;;29275:14:0;;;;;;;;;;29182:115::o;28976:24::-;;;-1:-1:-1;;;;;28976:24:0;;:::o;28873:25::-;;;;:::o;29611:131::-;29695:5;;-1:-1:-1;;;;;29695:5:0;29681:10;:19;29673:28;;;;;;29712:9;:22;;-1:-1:-1;;;;;;29712:22:0;-1:-1:-1;;;;;29712:22:0;;;;;;;;;;29611:131::o;29305:151::-;29399:5;;-1:-1:-1;;;;;29399:5:0;29385:10;:19;29377:28;;;;;;29416:14;:32;;-1:-1:-1;;;;;;29416:32:0;-1:-1:-1;;;;;29416:32:0;;;;;;;;;;29305:151::o;28907:29::-;;;-1:-1:-1;;;;;28907:29:0;;:::o;29009:43::-;;;;;;;;;;;;;;;:::o;29464:139::-;29552:5;;-1:-1:-1;;;;;29552:5:0;29538:10;:19;29530:28;;;;;;29569:11;:26;;-1:-1:-1;;;;;;29569:26:0;-1:-1:-1;;;;;29569:26:0;;;;;;;;;;29464:139::o;28846:20::-;;;-1:-1:-1;;;;;28846:20:0;;:::o;31349:1005::-;-1:-1:-1;;;;;31462:16:0;;31437:4;31462:16;;;:10;:16;;;;;;;;:24;;:16;:24;;31454:51;;;;;-1:-1:-1;;;31454:51:0;;;;;;;;;;;;-1:-1:-1;;;31454:51:0;;;;;;;;;;;;;;;31534:1;31524:7;:11;31516:20;;;;;;31555:42;31566:6;;31574:22;31582:4;31588:7;31574;:22::i;:::-;31555:10;:42::i;:::-;31547:72;;;;;-1:-1:-1;;;31547:72:0;;;;;;;;;;;;-1:-1:-1;;;31547:72:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;31632:16:0;;;;;;;:10;:16;;;;;:23;;-1:-1:-1;;31632:23:0;31651:4;31632:23;;;31671:11;;;:25;31668:619;;31761:11;;31754:47;;-1:-1:-1;;;;;31761:11:0;31787:4;31793:7;31754:32;:47::i;:::-;31668:619;;;31821:9;;-1:-1:-1;;;;;31821:9:0;:23;31818:469;;31909:9;;;31896:43;;;-1:-1:-1;;;31896:43:0;;-1:-1:-1;;;;;31896:43:0;;;;;;;;;;;;;;;;;;31909:9;;;;;31896:28;;:43;;;;;31909:9;;31896:43;;;;;;;;31909:9;;31896:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31818:469;;;32072:16;;;32086:1;32072:16;;;;;;;;;32047:22;;32072:16;;;;;;;;;;;-1:-1:-1;32072:16:0;32047:41;;32114:4;32103:5;32109:1;32103:8;;;;;;;;-1:-1:-1;;;;;32103:15:0;;;;:8;;;;;;;;;;;:15;32160:16;;;32174:1;32160:16;;;;;;;;;32133:24;;32160:16;;;;;;;;;;;;-1:-1:-1;32160:16:0;32133:43;;32204:7;32191;32199:1;32191:10;;;;;;;;;;;;;;;;;;:20;;;;32240:14;;32226:49;;;-1:-1:-1;;;32226:49:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;32240:14:0;;;;32226:34;;32261:5;;32267:7;;32226:49;;;;;;;;;;;;;;;;;;;32240:14;32226:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;31818:469:0;32304:20;;;-1:-1:-1;;;;;32304:20:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32342:4:0;31349:1005;;;;;;:::o;29750:129::-;29830:5;;-1:-1:-1;;;;;29830:5:0;29816:10;:19;29808:28;;;;;;29847:10;:24;29750:129::o;28943:26::-;;;-1:-1:-1;;;;;28943:26:0;;:::o;31085:254::-;31168:27;;;;;;;;;;;-1:-1:-1;;;31168:27:0;;;;;;;;31206:25;;;;;;;;;;;-1:-1:-1;;;31206:25:0;;;;31148:7;;31168:27;31285:24;31306:2;31285:20;:24::i;:::-;31310:5;31316:13;31326:2;31316:9;:13::i;:::-;31261:69;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31261:69:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31261:69:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31261:69:0;;;;;;;;;;;;;-1:-1:-1;;31261:69:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31261:69:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31261:69:0;;;;;;;;;;;;;-1:-1:-1;;31261:69:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31261:69:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31261:69:0;;;;;;;;;;;;;-1:-1:-1;;31261:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31251:80;;;;;;31244:87;;;;31085:254;;;;:::o;32362:465::-;32447:4;;32497:5;32447:4;32515:270;-1:-1:-1;;32537:17:0;;32532:22;;32515:270;;32584:6;;32591:1;32584:9;;;;;;;;;;;;;32579:14;;32618:2;32614:1;:6;32610:164;;;32672:1;32675:2;32655:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32645:34;;;;;;32641:38;;32610:164;;;32751:2;32755:1;32734:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32724:34;;;;;;32720:38;;32610:164;32561:1;32556:6;32515:270;;;-1:-1:-1;32809:10:0;;32804:15;;-1:-1:-1;;32362:465:0;;;;;;:::o;25048:177::-;25158:58;;;-1:-1:-1;;;;;25158:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;25158:58:0;-1:-1:-1;;;25158:58:0;;;25131:86;;25151:5;;25131:19;:86::i;:::-;25048:177;;;:::o;29887:437::-;29994:13;;;30004:2;29994:13;;;29951;29994;;;;;;29951;;29994;;;;;;;;;;;-1:-1:-1;29994:13:0;29977:30;;30023:6;30018:272;30039:2;30035:1;:6;30018:272;;;30063:6;30106:1;30101:2;:6;30098:1;:10;30094:1;:15;30088:1;-1:-1:-1;;;;;30083:7:0;:27;;;;;;30072:40;;30063:49;;30127:7;30153:2;30148:1;30142:8;;:13;;;;;;;;30137:19;;30127:29;;30171:7;30208:2;30202:9;;30197:2;:14;30192:1;30186:8;;:25;30181:31;;30171:41;;30236:8;30241:2;30236:4;:8::i;:::-;30227:1;30231;30229;:3;30227:6;;;;;;;;;;;:17;-1:-1:-1;;;;;30227:17:0;;;;;;;;;30270:8;30275:2;30270:4;:8::i;:::-;30259:1;30263;30261;:3;30265:1;30261:5;30259:8;;;;;;;;;;;:19;-1:-1:-1;;;;;30259:19:0;;;;;;;;-1:-1:-1;;30043:3:0;;;;;-1:-1:-1;30018:272:0;;-1:-1:-1;30018:272:0;;-1:-1:-1;30314:1:0;-1:-1:-1;29887:437:0;;;;:::o;30503:574::-;30554:27;30598:7;30594:50;;-1:-1:-1;30622:10:0;;;;;;;;;;;;-1:-1:-1;;;30622:10:0;;;;;;30594:50;30663:2;30654:6;30695:69;30702:6;;30695:69;;30725:5;;30750:2;30745:7;;;;30695:69;;;30774:17;30804:3;30794:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;30794:14:0;-1:-1:-1;30774:34:0;-1:-1:-1;30828:3:0;30842:198;30849:7;;30842:198;;-1:-1:-1;;30877:3:0;30895:10;30930:2;30925;:7;30935:2;30925:12;30920:2;:17;30909:2;:29;30895:44;;30954:9;30973:4;30966:12;;30954:24;;31003:2;30993:4;30998:1;30993:7;;;;;;;;;;;:12;-1:-1:-1;;;;;30993:12:0;;;;;;;;-1:-1:-1;31026:2:0;31020:8;;;;30842:198;;;;;-1:-1:-1;31064:4:0;30503:574;-1:-1:-1;;;;30503:574:0:o;27353:761::-;27777:23;27803:69;27831:4;27803:69;;;;;;;;;;;;;;;;;27811:5;-1:-1:-1;;;;;27803:27:0;;;:69;;;;;:::i;:::-;27887:17;;27777:95;;-1:-1:-1;27887:21:0;27883:224;;28029:10;28018:30;;;;;;;;;;;;;;;-1:-1:-1;28018:30:0;28010:85;;;;-1:-1:-1;;;28010:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30332:163;30377:6;30411:2;30400:8;;;;:13;30396:91;;;30433:1;30427:8;;30438:4;30427:15;30422:21;;30415:28;;;;30396:91;30477:1;30471:8;;30482:4;30471:15;30466:21;;30459:28;;;;12572:195;12675:12;12707:52;12729:6;12737:4;12743:1;12746:12;12707:21;:52::i;:::-;12700:59;12572:195;-1:-1:-1;;;;12572:195:0:o;13624:530::-;13751:12;13809:5;13784:21;:30;;13776:81;;;;-1:-1:-1;;;13776:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13876:18;13887:6;13876:10;:18::i;:::-;13868:60;;;;;-1:-1:-1;;;13868:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;14002:12;14016:23;14043:6;-1:-1:-1;;;;;14043:11:0;14063:5;14071:4;14043:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;14043:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14001:75;;;;14094:52;14112:7;14121:10;14133:12;14094:17;:52::i;:::-;14087:59;13624:530;-1:-1:-1;;;;;;;13624:530:0:o;9654:422::-;10021:20;10060:8;;;9654:422::o;16164:742::-;16279:12;16308:7;16304:595;;;-1:-1:-1;16339:10:0;16332:17;;16304:595;16453:17;;:21;16449:439;;16716:10;16710:17;16777:15;16764:10;16760:2;16756:19;16749:44;16664:148;16859:12;16852:20;;-1:-1:-1;;;16852:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://1f3ae06d6b1121c28342e2d25a400e061c3b05fb9dd779aa04ecc4fe2f55f9e4