Contract 0x1e487614bd3a1d5e5dd342186746198aac609c1b 1

/**
 *Submitted for verification at FtmScan.com on 2022-05-13
*/

// 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: @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/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/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/distribution/TombGenesisRewardPool.sol



pragma solidity 0.6.12;




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

    // governance
    address public operator;

    // 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. TOMB to distribute.
        uint256 lastRewardTime; // Last time that TOMB distribution occurs.
        uint256 accTombPerShare; // Accumulated TOMB per share, times 1e18. See below.
        bool isStarted; // if lastRewardBlock has passed
    }

    IERC20 public tomb;
    address public shiba;

    // 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 TOMB mining starts.
    uint256 public poolStartTime;

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

    // MAINNET
    uint256 public tombPerSecond = 0.14467 ether; //  TOMB / (48h * 60min * 60s)
    uint256 public runningTime = 2 days; // 2 days
    uint256 public constant TOTAL_REWARDS = 25000 ether;

    // END MAINNET
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    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 _tomb,
        /* ddress _shiba, */
        uint256 _poolStartTime
    ) public {
        require(block.timestamp < _poolStartTime, "late");
        if (_tomb != address(0)) tomb = IERC20(_tomb);
        /* if (_shiba != address(0)) shiba = _shiba; */
        poolStartTime = _poolStartTime;
        poolEndTime = poolStartTime + runningTime;
        operator = msg.sender;
    }

    modifier onlyOperator() {
        require(operator == msg.sender, "TombGenesisPool: 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, "TombGenesisPool: 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
    ) public onlyOperator {
        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,
            accTombPerShare : 0,
            isStarted : _isStarted
            }));
        if (_isStarted) {
            totalAllocPoint = totalAllocPoint.add(_allocPoint);
        }
    }

    // Update the given pool's TOMB allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
        massUpdatePools();
        PoolInfo storage pool = poolInfo[_pid];
        if (pool.isStarted) {
            totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(
                _allocPoint
            );
        }
        pool.allocPoint = _allocPoint;
    }

    // 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(tombPerSecond);
            return poolEndTime.sub(_fromTime).mul(tombPerSecond);
        } else {
            if (_toTime <= poolStartTime) return 0;
            if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(tombPerSecond);
            return _toTime.sub(_fromTime).mul(tombPerSecond);
        }
    }

    // View function to see pending TOMB on frontend.
    function pendingTOMB(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accTombPerShare = pool.accTombPerShare;
        uint256 tokenSupply = pool.token.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
            uint256 _tombReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            accTombPerShare = accTombPerShare.add(_tombReward.mul(1e18).div(tokenSupply));
        }
        return user.amount.mul(accTombPerShare).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 _tombReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            pool.accTombPerShare = pool.accTombPerShare.add(_tombReward.mul(1e18).div(tokenSupply));
        }
        pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens.
    function deposit(uint256 _pid, uint256 _amount) public {
        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.accTombPerShare).div(1e18).sub(user.rewardDebt);
            if (_pending > 0) {
                safeTombTransfer(_sender, _pending);
                emit RewardPaid(_sender, _pending);
            }
        }
        if (_amount > 0) {
            pool.token.safeTransferFrom(_sender, address(this), _amount);
            if(address(pool.token) == shiba) {
                user.amount = user.amount.add(_amount.mul(9900).div(10000));
            } else {
                user.amount = user.amount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accTombPerShare).div(1e18);
        emit Deposit(_sender, _pid, _amount);
    }

    // Withdraw LP tokens.
    function withdraw(uint256 _pid, uint256 _amount) public {
        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.accTombPerShare).div(1e18).sub(user.rewardDebt);
        if (_pending > 0) {
            safeTombTransfer(_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.accTombPerShare).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 TOMB transfer function, just in case if rounding error causes pool to not have enough TOMBs.
    function safeTombTransfer(address _to, uint256 _amount) internal {
        uint256 _tombBalance = tomb.balanceOf(address(this));
        if (_tombBalance > 0) {
            if (_amount > _tombBalance) {
                tomb.safeTransfer(_to, _tombBalance);
            } else {
                tomb.safeTransfer(_to, _amount);
            }
        }
    }

    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 (TOMB or lps) if less than 90 days after pool ends
            require(_token != tomb, "tomb");
            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":"_tomb","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":"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"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","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":"pendingTOMB","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":"uint256","name":"accTombPerShare","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"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shiba","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tomb","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tombPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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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

0000000000000000000000009b8e797c216778f5e1a111391f8e9ac9da2a2df90000000000000000000000000000000000000000000000000000000062801850

-----Decoded View---------------
Arg [0] : _tomb (address): 0x9b8e797c216778f5e1a111391f8e9ac9da2a2df9
Arg [1] : _poolStartTime (uint256): 1652562000

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000009b8e797c216778f5e1a111391f8e9ac9da2a2df9
Arg [1] : 0000000000000000000000000000000000000000000000000000000062801850

22320:10819:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23780:51;;;:::i;:::-;;;;;;;;;;;;;;;;;;;23188:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23433:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;26450:353;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26880:653;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;30678:810;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;28706:908;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;31559:377;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;32532:604;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;22441:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;23518:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;28450:180;;;:::i;:::-;;23595:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;27596:771;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;23272:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;23728:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;25078:1276;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23646:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;32423:101;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23107:18;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;23132:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;29649:993;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23780:51;23820:11;23780:51;:::o;23188:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;23433:34::-;;;;:::o;26450:353::-;24653:10;24641:22;;:8;;;;;;;;;;:22;;;24633:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26529:17:::1;:15;:17::i;:::-;26557:21;26581:8;26590:4;26581:14;;;;;;;;;;;;;;;;;;26557:38;;26610:4;:14;;;;;;;;;;;;26606:150;;;26659:85;26718:11;26659:36;26679:4;:15;;;26659;;:19;;:36;;;;:::i;:::-;:40;;:85;;;;:::i;:::-;26641:15;:103;;;;26606:150;26784:11;26766:4;:15;;:29;;;;24722:1;26450:353:::0;;:::o;26880:653::-;26965:7;27002;26989:9;:20;26985:34;;27018:1;27011:8;;;;26985:34;27045:11;;27034:7;:22;27030:496;;27090:11;;27077:9;:24;27073:38;;27110:1;27103:8;;;;27073:38;27143:13;;27130:9;:26;27126:88;;27165:49;27200:13;;27165:30;27181:13;;27165:11;;:15;;:30;;;;:::i;:::-;:34;;:49;;;;:::i;:::-;27158:56;;;;27126:88;27236:45;27267:13;;27236:26;27252:9;27236:11;;:15;;:26;;;;:::i;:::-;:30;;:45;;;;:::i;:::-;27229:52;;;;27030:496;27329:13;;27318:7;:24;27314:38;;27351:1;27344:8;;;;27314:38;27384:13;;27371:9;:26;27367:84;;27406:45;27437:13;;27406:26;27418:13;;27406:7;:11;;:26;;;;:::i;:::-;:30;;:45;;;;:::i;:::-;27399:52;;;;27367:84;27473:41;27500:13;;27473:22;27485:9;27473:7;:11;;:22;;;;:::i;:::-;:26;;:41;;;;:::i;:::-;27466:48;;26880:653;;;;;:::o;30678:810::-;30745:15;30763:10;30745:28;;30784:21;30808:8;30817:4;30808:14;;;;;;;;;;;;;;;;;;30784:38;;30833:21;30857:8;:14;30866:4;30857:14;;;;;;;;;;;:23;30872:7;30857:23;;;;;;;;;;;;;;;30833:47;;30914:7;30899:4;:11;;;:22;;30891:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30955:16;30966:4;30955:10;:16::i;:::-;30982;31001:68;31053:4;:15;;;31001:47;31043:4;31001:37;31017:4;:20;;;31001:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:68;;;;:::i;:::-;30982:87;;31095:1;31084:8;:12;31080:129;;;31113:35;31130:7;31139:8;31113:16;:35::i;:::-;31179:7;31168:29;;;31188:8;31168:29;;;;;;;;;;;;;;;;;;31080:129;31233:1;31223:7;:11;31219:138;;;31265:24;31281:7;31265:4;:11;;;:15;;:24;;;;:::i;:::-;31251:4;:11;;:38;;;;31304:41;31328:7;31337;31304:4;:10;;;;;;;;;;;;:23;;;;:41;;;;;:::i;:::-;31219:138;31385:47;31427:4;31385:37;31401:4;:20;;;31385:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;31367:4;:15;;:65;;;;31466:4;31457:7;31448:32;;;31472:7;31448:32;;;;;;;;;;;;;;;;;;30678:810;;;;;;:::o;28706:908::-;28758:21;28782:8;28791:4;28782:14;;;;;;;;;;;;;;;;;;28758:38;;28830:4;:19;;;28811:15;:38;28807:77;;28866:7;;;28807:77;28894:19;28916:4;:10;;;;;;;;;;;;:20;;;28945:4;28916:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28894:57;;28981:1;28966:11;:16;28962:107;;;29021:15;28999:4;:19;;:37;;;;29051:7;;;;28962:107;29084:4;:14;;;;;;;;;;;;29079:138;;29132:4;29115;:14;;;:21;;;;;;;;;;;;;;;;;;29169:36;29189:4;:15;;;29169;;:19;;:36;;;;:::i;:::-;29151:15;:54;;;;29079:138;29249:1;29231:15;;:19;29227:332;;;29267:24;29294:56;29313:4;:19;;;29334:15;29294:18;:56::i;:::-;29267:83;;29365:19;29387:58;29429:15;;29387:37;29408:4;:15;;;29387:16;:20;;:37;;;;:::i;:::-;:41;;:58;;;;:::i;:::-;29365:80;;29483:64;29508:38;29534:11;29508:21;29524:4;29508:11;:15;;:21;;;;:::i;:::-;:25;;:38;;;;:::i;:::-;29483:4;:20;;;:24;;:64;;;;:::i;:::-;29460:4;:20;;:87;;;;29227:332;;;29591:15;29569:4;:19;;:37;;;;28706:908;;;;:::o;31559:377::-;31618:21;31642:8;31651:4;31642:14;;;;;;;;;;;;;;;;;;31618:38;;31667:21;31691:8;:14;31700:4;31691:14;;;;;;;;;;;:26;31706:10;31691:26;;;;;;;;;;;;;;;31667:50;;31728:15;31746:4;:11;;;31728:29;;31782:1;31768:4;:11;;:15;;;;31812:1;31794:4;:15;;:19;;;;31824:44;31848:10;31860:7;31824:4;:10;;;;;;;;;;;;:23;;;;:44;;;;;:::i;:::-;31914:4;31902:10;31884:44;;;31920:7;31884:44;;;;;;;;;;;;;;;;;;31559:377;;;;:::o;32532:604::-;24653:10;24641:22;;:8;;;;;;;;;;:22;;;24633:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32682:7:::1;32668:11;;:21;32650:15;:39;32646:441;;;32824:4;;;;;;;;;;;32814:14;;:6;:14;;;;32806:31;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;32852:14;32869:8;:15;;;;32852:32;;32904:11;32899:177;32927:6;32921:3;:12;32899:177;;;32961:21;32985:8;32994:3;32985:13;;;;;;;;;;;;;;;;;;32961:37;;33035:4;:10;;;;;;;;;;;;33025:20;;:6;:20;;;;33017:43;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;32899:177;32935:5;;;;;32899:177;;;;32646:441;;33097:31;33117:2;33121:6;33097;:19;;;;:31;;;;;:::i;:::-;32532:604:::0;;;:::o;22441:23::-;;;;;;;;;;;;:::o;23518:28::-;;;;:::o;28450:180::-;28495:14;28512:8;:15;;;;28495:32;;28543:11;28538:85;28566:6;28560:3;:12;28538:85;;;28596:15;28607:3;28596:10;:15::i;:::-;28574:5;;;;;28538:85;;;;28450:180;:::o;23595:26::-;;;;:::o;27596:771::-;27669:7;27689:21;27713:8;27722:4;27713:14;;;;;;;;;;;;;;;;;;27689:38;;27738:21;27762:8;:14;27771:4;27762:14;;;;;;;;;;;:21;27777:5;27762:21;;;;;;;;;;;;;;;27738:45;;27794:23;27820:4;:20;;;27794:46;;27851:19;27873:4;:10;;;;;;;;;;;;:20;;;27902:4;27873:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27851:57;;27941:4;:19;;;27923:15;:37;:57;;;;;27979:1;27964:11;:16;;27923:57;27919:360;;;27997:24;28024:56;28043:4;:19;;;28064:15;28024:18;:56::i;:::-;27997:83;;28095:19;28117:58;28159:15;;28117:37;28138:4;:15;;;28117:16;:20;;:37;;;;:::i;:::-;:41;;:58;;;;:::i;:::-;28095:80;;28208:59;28228:38;28254:11;28228:21;28244:4;28228:11;:15;;:21;;;;:::i;:::-;:25;;:38;;;;:::i;:::-;28208:15;:19;;:59;;;;:::i;:::-;28190:77;;27919:360;;;28296:63;28343:4;:15;;;28296:42;28333:4;28296:32;28312:15;28296:4;:11;;;:15;;:32;;;;:::i;:::-;:36;;:42;;;;:::i;:::-;:46;;:63;;;;:::i;:::-;28289:70;;;;;;27596:771;;;;:::o;23272:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;23728:35::-;;;;:::o;25078:1276::-;24653:10;24641:22;;:8;;;;;;;;;;:22;;;24633:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25244:26:::1;25263:6;25244:18;:26::i;:::-;25285:11;25281:61;;;25313:17;:15;:17::i;:::-;25281:61;25374:13;;25356:15;:31;25352:534;;;25460:1;25441:15;:20;25437:243;;;25500:13;;25482:31;;25437:243;;;25576:13;;25558:15;:31;25554:111;;;25632:13;;25614:31;;25554:111;25437:243;25352:534;;;25767:1;25748:15;:20;:57;;;;25790:15;25772;:33;25748:57;25744:131;;;25844:15;25826:33;;25744:131;25352:534;25896:15;25943:13;;25924:15;:32;;25923:83;;;;25990:15;25971;:34;;25923:83;25896:110;;26017:8;26031:211;;;;;;;;26063:6;26031:211;;;;;;26097:11;26031:211;;;;26140:15;26031:211;;;;26188:1;26031:211;;;;26216:10;26031:211;;;;::::0;26017:226:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26258:10;26254:93;;;26303:32;26323:11;26303:15;;:19;;:32;;;;:::i;:::-;26285:15;:50;;;;26254:93;24722:1;25078:1276:::0;;;;:::o;23646:44::-;;;;:::o;32423:101::-;24653:10;24641:22;;:8;;;;;;;;;;:22;;;24633:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32507:9:::1;32496:8;::::0;:20:::1;;;;;;;;;;;;;;;;;;32423:101:::0;:::o;23107:18::-;;;;;;;;;;;;;:::o;23132:20::-;;;;;;;;;;;;;:::o;29649:993::-;29715:15;29733:10;29715:28;;29754:21;29778:8;29787:4;29778:14;;;;;;;;;;;;;;;;;;29754:38;;29803:21;29827:8;:14;29836:4;29827:14;;;;;;;;;;;:23;29842:7;29827:23;;;;;;;;;;;;;;;29803:47;;29861:16;29872:4;29861:10;:16::i;:::-;29906:1;29892:4;:11;;;:15;29888:290;;;29924:16;29943:68;29995:4;:15;;;29943:47;29985:4;29943:37;29959:4;:20;;;29943:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:68;;;;:::i;:::-;29924:87;;30041:1;30030:8;:12;30026:141;;;30063:35;30080:7;30089:8;30063:16;:35::i;:::-;30133:7;30122:29;;;30142:8;30122:29;;;;;;;;;;;;;;;;;;30026:141;29888:290;;30202:1;30192:7;:11;30188:324;;;30220:60;30248:7;30265:4;30272:7;30220:4;:10;;;;;;;;;;;;:27;;;;:60;;;;;;:::i;:::-;30321:5;;;;;;;;;;;30298:28;;30306:4;:10;;;;;;;;;;;;30298:28;;;30295:206;;;30361:45;30377:28;30399:5;30377:17;30389:4;30377:7;:11;;:17;;;;:::i;:::-;:21;;:28;;;;:::i;:::-;30361:4;:11;;;:15;;:45;;;;:::i;:::-;30347:4;:11;;:59;;;;30295:206;;;30461:24;30477:7;30461:4;:11;;;:15;;:24;;;;:::i;:::-;30447:4;:11;;:38;;;;30295:206;30188:324;30540:47;30582:4;30540:37;30556:4;:20;;;30540:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;30522:4;:15;;:65;;;;30620:4;30611:7;30603:31;;;30626:7;30603:31;;;;;;;;;;;;;;;;;;29649:993;;;;;:::o;11292:158::-;11350:7;11383:1;11378;:6;;11370:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11441:1;11437;:5;11430:12;;11292:158;;;;:::o;10830:179::-;10888:7;10908:9;10924:1;10920;:5;10908:17;;10949:1;10944;:6;;10936:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11000:1;10993:8;;;10830:179;;;;:::o;11709:220::-;11767:7;11796:1;11791;:6;11787:20;;;11806:1;11799:8;;;;11787:20;11818:9;11834:1;11830;:5;11818:17;;11863:1;11858;11854;:5;;;;;;:10;11846:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11920:1;11913:8;;;11709:220;;;;;:::o;12407:153::-;12465:7;12497:1;12493;:5;12485:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12551:1;12547;:5;;;;;;12540:12;;12407:153;;;;:::o;32050:365::-;32126:20;32149:4;;;;;;;;;;;:14;;;32172:4;32149:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32126:52;;32208:1;32193:12;:16;32189:219;;;32240:12;32230:7;:22;32226:171;;;32273:36;32291:3;32296:12;32273:4;;;;;;;;;;;:17;;;;:36;;;;;:::i;:::-;32226:171;;;32350:31;32368:3;32373:7;32350:4;;;;;;;;;;;:17;;;;:31;;;;;:::i;:::-;32226:171;32189:219;32050:365;;;:::o;18974:177::-;19057:86;19077:5;19107:23;;;19132:2;19136:5;19084:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19057:19;:86::i;:::-;18974:177;;;:::o;24739:261::-;24807:14;24824:8;:15;;;;24807:32;;24855:11;24850:143;24878:6;24872:3;:12;24850:143;;;24939:6;24916:29;;:8;24925:3;24916:13;;;;;;;;;;;;;;;;;;:19;;;;;;;;;;;;:29;;;;24908:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24886:5;;;;;24850:143;;;;24739:261;;:::o;19159:205::-;19260:96;19280:5;19310:27;;;19339:4;19345:2;19349:5;19287:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19260:19;:96::i;:::-;19159:205;;;;:::o;21279:761::-;21703:23;21729:69;21757:4;21729:69;;;;;;;;;;;;;;;;;21737:5;21729:27;;;;:69;;;;;:::i;:::-;21703:95;;21833:1;21813:10;:17;:21;21809:224;;;21955:10;21944:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21936:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21809:224;21279:761;;;:::o;3692:195::-;3795:12;3827:52;3849:6;3857:4;3863:1;3866:12;3827:21;:52::i;:::-;3820:59;;3692:195;;;;;:::o;4744:530::-;4871:12;4929:5;4904:21;:30;;4896:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4996:18;5007:6;4996:10;:18::i;:::-;4988:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5122:12;5136:23;5163:6;:11;;5183:5;5191:4;5163:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5121:75;;;;5214:52;5232:7;5241:10;5253:12;5214:17;:52::i;:::-;5207:59;;;;4744:530;;;;;;:::o;774:422::-;834:4;1042:12;1153:7;1141:20;1133:28;;1187:1;1180:4;:8;1173:15;;;774:422;;;:::o;7284:742::-;7399:12;7428:7;7424:595;;;7459:10;7452:17;;;;7424:595;7593:1;7573:10;:17;:21;7569:439;;;7836:10;7830:17;7897:15;7884:10;7880:2;7876:19;7869:44;7784:148;7979:12;7972:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7284:742;;;;;;:::o

ipfs://1e65fe7ae8d365f7a15d026bbca5b297acc8eab3cd86a5969374aa5a386c949a