Contract

/**
 *Submitted for verification at Etherscan.io on 2021-02-27
*/

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

// SPDX-License-Identifier: MIT

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\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: contracts\HLDVesting.sol



pragma solidity 0.6.12;



/**
 * @title TokenVesting
 * @dev A token holder contract that can release its token balance gradually like a
 * typical vesting scheme, with a vesting period.
 */
contract TokenVesting {
    // The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
    // therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
    // it is recommended to avoid using short time durations (less than a minute).
    // solhint-disable not-rely-on-time

    using SafeMath for uint256;

    event TokensReleased(address token, uint256 amount);

    // beneficiary of tokens after they are released
    address private immutable _beneficiary;

    // Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
    uint256 private immutable _start;
    uint256 private immutable _duration;
    // The amount of token can be released with the first release
    uint256 private immutable _initialRelease;

    mapping (address => uint256) private _released;

    /**
     * @dev Creates a vesting contract that vests its balance of any ERC20 token to the
     * beneficiary, gradually in a linear fashion until start + duration. By then all
     * of the balance will have vested.
     * @param beneficiary address of the beneficiary to whom vested tokens are transferred
     * @param start the time (as Unix time) at which point vesting starts
     * @param duration duration in seconds of the period in which the tokens will vest
     * @param initialRelease The amount of token can be released with the first release
     */
    constructor (address beneficiary, uint256 start, uint256 duration, uint256 initialRelease) public {
        require(beneficiary != address(0), "TokenVesting: beneficiary is the zero address");

        require(duration > 0, "TokenVesting: duration is 0");
        // solhint-disable-next-line max-line-length
        require(start.add(duration) > block.timestamp, "TokenVesting: final time is before current time");

        _beneficiary = beneficiary;
        _duration = duration;
        _start = start;
        _initialRelease = initialRelease;
    }

    // Copied and modified Openzepplin TokenVesting contract:
    // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.0.0/contracts/drafts/TokenVesting.sol

    /**
     * @return the beneficiary of the tokens.
     */
    function beneficiary() public view returns (address) {
        return _beneficiary;
    }

    /**
     * @return the start time of the token vesting.
     */
    function start() public view returns (uint256) {
        return _start;
    }

    /**
     * @return the duration of the token vesting.
     */
    function duration() public view returns (uint256) {
        return _duration;
    }

    /**
     * @return the initial release of the tokens.
     */
    function initialRelease() public view returns (uint256) {
        return _initialRelease;
    }

    /**
     * @return the amount of the token released.
     */
    function released(address token) public view returns (uint256) {
        return _released[token];
    }

    /**
     * @notice Transfers vested tokens to beneficiary.
     * @param token ERC20 token which is being vested
     */
    function release(IERC20 token) public {
        require (msg.sender == _beneficiary, "The message sender is not beneficiary");
        
        uint256 unreleased = _releasableAmount(token);

        require(unreleased > 0, "TokenVesting: no tokens are due");

        _released[address(token)] = _released[address(token)].add(unreleased);

        token.transfer(_beneficiary, unreleased);

        emit TokensReleased(address(token), unreleased);
    }

    /**
     * @dev Calculates the amount that has already vested but hasn't been released yet.
     * @param token ERC20 token which is being vested
     */
    function _releasableAmount(IERC20 token) private view returns (uint256) {
        return (_initialRelease.add(_vestedAmount(token))).sub(_released[address(token)]);
    }

    /**
     * @dev Calculates the amount that has already vested.
     * @param token ERC20 token which is being vested
     */
    function _vestedAmount(IERC20 token) private view returns (uint256) {
        uint256 currentBalance = token.balanceOf(address(this));
        uint256 totalBalance = currentBalance.add(_released[address(token)]);
        totalBalance = totalBalance.sub(_initialRelease);

        if (block.timestamp >= _start.add(_duration)) {
            return totalBalance;
        } else {
            return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint256","name":"initialRelease","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensReleased","type":"event"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialRelease","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000060986ff09aba9023b7698f2a14c6910df93049910000000000000000000000000000000000000000000000000000000060650d0000000000000000000000000000000000000000000000000000000000078615600000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : beneficiary (address): 0x60986Ff09ABA9023B7698F2A14c6910Df9304991
Arg [1] : start (uint256): 1617235200
Arg [2] : duration (uint256): 126227808
Arg [3] : initialRelease (uint256): 0

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000060986ff09aba9023b7698f2a14c6910df9304991
Arg [1] : 0000000000000000000000000000000000000000000000000000000060650d00
Arg [2] : 0000000000000000000000000000000000000000000000000000000007861560
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000

10548:4675:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13210:85;;;:::i;:::-;;;;;;;;;;;;;;;;13787:466;;;;;;;;;;;;;;;;-1:-1:-1;13787:466:0;-1:-1:-1;;;;;13787:466:0;;:::i;:::-;;12884:91;;;:::i;:::-;;;;-1:-1:-1;;;;;12884:91:0;;;;;;;;;;;;;;13372:97;;;:::i;13545:105::-;;;;;;;;;;;;;;;;-1:-1:-1;13545:105:0;-1:-1:-1;;;;;13545:105:0;;:::i;13054:79::-;;;:::i;13210:85::-;13278:9;13210:85;:::o;13787:466::-;13845:10;-1:-1:-1;;;;;13859:12:0;13845:26;;13836:77;;;;-1:-1:-1;;;13836:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13934:18;13955:24;13973:5;13955:17;:24::i;:::-;13934:45;;14013:1;14000:10;:14;13992:58;;;;;-1:-1:-1;;;13992:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;14091:25:0;;:9;:25;;;;;;;;;;;:41;;14121:10;14091:29;:41::i;:::-;-1:-1:-1;;;;;14063:25:0;;;:9;:25;;;;;;;;;;;:69;;;;14145:40;;-1:-1:-1;;;14145:40:0;;14160:12;14145:40;;;;;;;;;;;;;;;14063:25;;14145:14;;:40;;;;;14063:25;;14145:40;;;;;;;;14063:25;14145:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;14203:42:0;;;-1:-1:-1;;;;;14203:42:0;;;;14145:40;14203:42;;;;;;;;;;;;;;;;;;13787:466;;:::o;12884:91::-;12955:12;12884:91;:::o;13372:97::-;13446:15;13372:97;:::o;13545:105::-;-1:-1:-1;;;;;13626:16:0;;13599:7;13626:16;;;;;;;;;;;13545:105;;;;:::o;13054:79::-;13119:6;13054:79;:::o;5639:179::-;5697:7;5729:5;;;5753:6;;;;5745:46;;;;;-1:-1:-1;;;5745:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5809:1;-1:-1:-1;5639:179:0;;;;;:::o;14423:172::-;-1:-1:-1;;;;;14561:25:0;;14486:7;14561:25;;;;;;;;;;;14513:74;;14514:41;14534:20;14579:5;14534:13;:20::i;:::-;14514:15;;:19;:41::i;:::-;14513:47;;:74::i;14736:484::-;14795:7;14815:22;14840:5;-1:-1:-1;;;;;14840:15:0;;14864:4;14840:30;;;;;;;;;;;;;-1:-1:-1;;;;;14840:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14840:30:0;-1:-1:-1;;;;;14923:25:0;;14881:20;14923:25;;;14840:30;14923:25;;;;;;;14840:30;;-1:-1:-1;14881:20:0;14904:45;;14840:30;;14904:18;:45::i;:::-;14881:68;-1:-1:-1;14975:33:0;14881:68;14992:15;14975:16;:33::i;:::-;14960:48;-1:-1:-1;15044:21:0;:6;15055:9;15044:10;:21::i;:::-;15025:15;:40;15021:192;;15089:12;-1:-1:-1;15082:19:0;;-1:-1:-1;15082:19:0;15021:192;15141:60;15191:9;15141:45;15158:27;:15;15178:6;15158:19;:27::i;:::-;15141:12;;:16;:45::i;:::-;:49;;:60::i;:::-;15134:67;;;;;;6101:158;6159:7;6192:1;6187;:6;;6179:49;;;;;-1:-1:-1;;;6179:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6246:5:0;;;6101:158::o;6518:220::-;6576:7;6600:6;6596:20;;-1:-1:-1;6615:1:0;6608:8;;6596:20;6639:5;;;6643:1;6639;:5;:1;6663:5;;;;;:10;6655:56;;;;-1:-1:-1;;;6655:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7216:153;7274:7;7306:1;7302;:5;7294:44;;;;;-1:-1:-1;;;7294:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7360:1;7356;:5;;;;;;;7216:153;-1:-1:-1;;;7216:153:0:o

ipfs://50166d9812141abf647e21c37fab5bc4a6fb44fa4e24861bac02412f41bfd6db