Contract Address Details

//SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
	contract ReentrancyGuard {
		bool private _notEntered;

		constructor () internal {
			// Storing an initial non-zero value makes deployment a bit more
			// expensive, but in exchange the refund on every call to nonReentrant
			// will be lower in amount. Since refunds are capped to a percetange of
			// the total transaction's gas, it is best to keep them low in cases
			// like this one, to increase the likelihood of the full refund coming
			// into effect.
			_notEntered = true;
		}

		/**
		* @dev Prevents a contract from calling itself, directly or indirectly.
		* Calling a `nonReentrant` function from another `nonReentrant`
		* function is not supported. It is possible to prevent this from happening
		* by making the `nonReentrant` function external, and make it call a
		* `private` function that does the actual work.
		*/
		modifier nonReentrant() {
			// On the first call to nonReentrant, _notEntered will be true
			require(_notEntered, "ReentrancyGuard: reentrant call");

			// Any calls to nonReentrant after this point will fail
			_notEntered = false;

			_;

			// By storing the original value once again, a refund is triggered (see
			// https://eips.ethereum.org/EIPS/eip-2200)
			_notEntered = true;
		}
	}
	
	/**
	* @dev Standard math utilities missing in the Solidity language.
	*/
	library Math {
		/**
		* @dev Returns the largest of two numbers.
		*/
		function max(uint256 a, uint256 b) internal pure returns (uint256) {
			return a >= b ? a : b;
		}

		/**
		* @dev Returns the smallest of two numbers.
		*/
		function min(uint256 a, uint256 b) internal pure returns (uint256) {
			return a < b ? a : b;
		}

		/**
		* @dev Returns the average of two numbers. The result is rounded towards
		* zero.
		*/
		function average(uint256 a, uint256 b) internal pure returns (uint256) {
			// (a + b) / 2 can overflow, so we distribute
			return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
		}
	}
	library SafeKRC20 {
	    using SafeMath for uint256;
	    using Address for address;
	
	    function safeTransfer(
	        IKRC20 token,
	        address to,
	        uint256 value
	    ) internal {
	        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
	    }
	
	    function safeTransferFrom(
	        IKRC20 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
	     * {IKRC20-approve}, and its usage is discouraged.
	     *
	     * Whenever possible, use {safeIncreaseAllowance} and
	     * {safeDecreaseAllowance} instead.
	     */
	    function safeApprove(
	        IKRC20 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),
	            'SafeKRC20: approve from non-zero to non-zero allowance'
	        );
	        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
	    }
	
	    function safeIncreaseAllowance(
	        IKRC20 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(
	        IKRC20 token,
	        address spender,
	        uint256 value
	    ) internal {
	        uint256 newAllowance = token.allowance(address(this), spender).sub(
	            value,
	            'SafeKRC20: 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(IKRC20 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, 'SafeKRC20: low-level call failed');
	        if (returndata.length > 0) {
	            // Return data is optional
	            // solhint-disable-next-line max-line-length
	            require(abi.decode(returndata, (bool)), 'SafeKRC20: KRC20 operation did not succeed');
	        }
	    }
	}
	contract Context {
	    // Empty internal constructor, to prevent people from mistakenly deploying
	    // an instance of this contract, which should be used via inheritance.
	    constructor() internal {}
	
	    function _msgSender() internal view returns (address payable) {
	        return msg.sender;
	    }
	
	    function _msgData() internal view returns (bytes memory) {
	        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
	        return msg.data;
	    }
	}
	contract Ownable is Context {
	    address private _owner;
	
	    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
	
	    /**
	     * @dev Initializes the contract setting the deployer as the initial owner.
	     */
	    constructor() internal {
	        address msgSender = _msgSender();
	        _owner = msgSender;
	        emit OwnershipTransferred(address(0), msgSender);
	    }
	
	    /**
	     * @dev Returns the address of the current owner.
	     */
	    function owner() public view returns (address) {
	        return _owner;
	    }
	
	    /**
	     * @dev Throws if called by any account other than the owner.
	     */
	    modifier onlyOwner() {
	        require(_owner == _msgSender(), 'Ownable: caller is not the owner');
	        _;
	    }
	
	    /**
	     * @dev Leaves the contract without owner. It will not be possible to call
	     * `onlyOwner` functions anymore. Can only be called by the current owner.
	     *
	     * NOTE: Renouncing ownership will leave the contract without an owner,
	     * thereby removing any functionality that is only available to the owner.
	     */
	    function renounceOwnership() public onlyOwner {
	        emit OwnershipTransferred(_owner, address(0));
	        _owner = address(0);
	    }
	
	    /**
	     * @dev Transfers ownership of the contract to a new account (`newOwner`).
	     * Can only be called by the current owner.
	     */
	    function transferOwnership(address newOwner) public onlyOwner {
	        _transferOwnership(newOwner);
	    }
	
	    /**
	     * @dev Transfers ownership of the contract to a new account (`newOwner`).
	     */
	    function _transferOwnership(address newOwner) internal {
	        require(newOwner != address(0), 'Ownable: new owner is the zero address');
	        emit OwnershipTransferred(_owner, newOwner);
	        _owner = newOwner;
	    }
	}
	interface IKRC20 {
	    /**
	     * @dev Returns the amount of tokens in existence.
	     */
	    function totalSupply() external view returns (uint256);
	
	    function preMineSupply() external view returns (uint256);
	
	    function maxSupply() external view returns (uint256);
	
	    /**
	     * @dev Returns the token decimals.
	     */
	    function decimals() external view returns (uint8);
	
	    /**
	     * @dev Returns the token symbol.
	     */
	    function symbol() external view returns (string memory);
	
	    /**
	     * @dev Returns the token name.
	     */
	    function name() external view returns (string memory);
	
	    /**
	     * @dev Returns the KRC token owner.
	     */
	    function getOwner() external view returns (address);
	
	    /**
	     * @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);
	}
	library SafeMath {
	    /**
	     * @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) {
	        return sub(a, b, 'SafeMath: subtraction overflow');
	    }
	
	    /**
	     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
	     * overflow (when the result is negative).
	     *
	     * 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);
	        uint256 c = a - b;
	
	        return c;
	    }
	
	    /**
	     * @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) {
	        // 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 0;
	        }
	
	        uint256 c = a * b;
	        require(c / a == b, 'SafeMath: multiplication overflow');
	
	        return c;
	    }
	
	    /**
	     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
	        return div(a, b, 'SafeMath: division by zero');
	    }
	
	    /**
	     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
	     * division by zero. The result is rounded towards zero.
	     *
	     * Counterpart to Solidity's `/` operator. Note: this function uses a
	     * `revert` opcode (which leaves remaining gas untouched) while Solidity
	     * uses an invalid opcode to revert (consuming all remaining gas).
	     *
	     * Requirements:
	     *
	     * - The divisor cannot be zero.
	     */
	    function div(
	        uint256 a,
	        uint256 b,
	        string memory errorMessage
	    ) internal pure returns (uint256) {
	        require(b > 0, errorMessage);
	        uint256 c = a / b;
	        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
	
	        return c;
	    }
	
	    /**
	     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
	     * Reverts when dividing by zero.
	     *
	     * Counterpart to Solidity's `%` operator. This function uses a `revert`
	     * opcode (which leaves remaining gas untouched) while Solidity uses an
	     * invalid opcode to revert (consuming all remaining gas).
	     *
	     * Requirements:
	     *
	     * - The divisor cannot be zero.
	     */
	    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
	        return mod(a, b, 'SafeMath: modulo by zero');
	    }
	
	    /**
	     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
	     * Reverts with custom message 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,
	        string memory errorMessage
	    ) internal pure returns (uint256) {
	        require(b != 0, errorMessage);
	        return a % b;
	    }
	
	    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
	        z = x < y ? x : y;
	    }
	
	    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
	    function sqrt(uint256 y) internal pure returns (uint256 z) {
	        if (y > 3) {
	            z = y;
	            uint256 x = y / 2 + 1;
	            while (x < z) {
	                z = x;
	                x = (y / x + x) / 2;
	            }
	        } else if (y != 0) {
	            z = 1;
	        }
	    }
	}
	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) {
	        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
	        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
	        // for accounts without code, i.e. `keccak256('')`
	        bytes32 codehash;
	        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
	        // solhint-disable-next-line no-inline-assembly
	        assembly {
	            codehash := extcodehash(account)
	        }
	        return (codehash != accountHash && codehash != 0x0);
	    }
	
	    /**
	     * @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');
	        return _functionCallWithValue(target, data, value, errorMessage);
	    }
	
	    function _functionCallWithValue(
	        address target,
	        bytes memory data,
	        uint256 weiValue,
	        string memory errorMessage
	    ) private returns (bytes memory) {
	        require(isContract(target), 'Address: call to non-contract');
	
	        // solhint-disable-next-line avoid-low-level-calls
	        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
	        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);
	            }
	        }
	    }
	}
	
	contract KRC20 is Context, IKRC20, Ownable {
	    uint256 private constant _preMineSupply = 5000000 * 1e18;
	    uint256 private constant _maxSupply = 350000000 * 1e18; 
	
	    using SafeMath for uint256;
	    using Address for address;
	
	    mapping(address => uint256) private _balances;
	
	    mapping(address => mapping(address => uint256)) private _allowances;
	
	    uint256 private _totalSupply;
	
	    string private _name;
	    string private _symbol;
	    uint8 private _decimals;
	
	    /**
	     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
	     * a default value of 18.
	     *
	     * To select a different value for {decimals}, use {_setupDecimals}.
	     *
	     * All three of these values are immutable: they can only be set once during
	     * construction.
	     */
	    constructor(string memory name, string memory symbol) public {
	        _name = name;
	        _symbol = symbol;
	        _decimals = 18;
	
	        _mint(msg.sender, _preMineSupply);
	    }
	
	    /**
	     * @dev Returns the KRC token owner.
	     */
	    function getOwner() external override view returns (address) {
	        return owner();
	    }
	
	    /**
	     * @dev Returns the token name.
	     */
	    function name() public override view returns (string memory) {
	        return _name;
	    }
	
	    /**
	     * @dev Returns the token decimals.
	     */
	    function decimals() public override view returns (uint8) {
	        return _decimals;
	    }
	
	    /**
	     * @dev Returns the token symbol.
	     */
	    function symbol() public override view returns (string memory) {
	        return _symbol;
	    }
	
	    /**
	     * @dev See {KRC20-totalSupply}.
	     */
	    function totalSupply() public override view returns (uint256) {
	        return _totalSupply;
	    }
	
	    function preMineSupply() public override view returns (uint256) {
	        return _preMineSupply;
	    }
	
	    function maxSupply() public override view returns (uint256) {
	        return _maxSupply;
	    }
	
	    /**
	     * @dev See {KRC20-balanceOf}.
	     */
	    function balanceOf(address account) public override view returns (uint256) {
	        return _balances[account];
	    }
	
	    /**
	     * @dev See {KRC20-transfer}.
	     *
	     * Requirements:
	     *
	     * - `recipient` cannot be the zero address.
	     * - the caller must have a balance of at least `amount`.
	     */
	    function transfer(address recipient, uint256 amount) public override returns (bool) {
	        _transfer(_msgSender(), recipient, amount);
	        return true;
	    }
	
	    /**
	     * @dev See {KRC20-allowance}.
	     */
	    function allowance(address owner, address spender) public override view returns (uint256) {
	        return _allowances[owner][spender];
	    }
	
	    /**
	     * @dev See {KRC20-approve}.
	     *
	     * Requirements:
	     *
	     * - `spender` cannot be the zero address.
	     */
	    function approve(address spender, uint256 amount) public override returns (bool) {
	        _approve(_msgSender(), spender, amount);
	        return true;
	    }
	
	    /**
	     * @dev See {KRC20-transferFrom}.
	     *
	     * Emits an {Approval} event indicating the updated allowance. This is not
	     * required by the EIP. See the note at the beginning of {KRC20};
	     *
	     * Requirements:
	     * - `sender` and `recipient` cannot be the zero address.
	     * - `sender` must have a balance of at least `amount`.
	     * - the caller must have allowance for `sender`'s tokens of at least
	     * `amount`.
	     */
	    function transferFrom(
	        address sender,
	        address recipient,
	        uint256 amount
	    ) public override returns (bool) {
	        _transfer(sender, recipient, amount);
	        _approve(
	            sender,
	            _msgSender(),
	            _allowances[sender][_msgSender()].sub(amount, 'KRC20: transfer amount exceeds allowance')
	        );
	        return true;
	    }
	
	    /**
	     * @dev Atomically increases the allowance granted to `spender` by the caller.
	     *
	     * This is an alternative to {approve} that can be used as a mitigation for
	     * problems described in {KRC20-approve}.
	     *
	     * Emits an {Approval} event indicating the updated allowance.
	     *
	     * Requirements:
	     *
	     * - `spender` cannot be the zero address.
	     */
	    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
	        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
	        return true;
	    }
	
	    /**
	     * @dev Atomically decreases the allowance granted to `spender` by the caller.
	     *
	     * This is an alternative to {approve} that can be used as a mitigation for
	     * problems described in {KRC20-approve}.
	     *
	     * Emits an {Approval} event indicating the updated allowance.
	     *
	     * Requirements:
	     *
	     * - `spender` cannot be the zero address.
	     * - `spender` must have allowance for the caller of at least
	     * `subtractedValue`.
	     */
	    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
	        _approve(
	            _msgSender(),
	            spender,
	            _allowances[_msgSender()][spender].sub(subtractedValue, 'KRC20: decreased allowance below zero')
	        );
	        return true;
	    }
	
	    /**
	     * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
	     * the total supply.
	     *
	     * Requirements
	     *
	     * - `msg.sender` must be the token owner
	     */
	    function mint(uint256 amount) public onlyOwner returns (bool) {
	        _mint(_msgSender(), amount);
	        return true;
	    }
	
	    /**
	     * @dev Moves tokens `amount` from `sender` to `recipient`.
	     *
	     * This is internal function is equivalent to {transfer}, and can be used to
	     * e.g. implement automatic token fees, slashing mechanisms, etc.
	     *
	     * Emits a {Transfer} event.
	     *
	     * Requirements:
	     *
	     * - `sender` cannot be the zero address.
	     * - `recipient` cannot be the zero address.
	     * - `sender` must have a balance of at least `amount`.
	     */
	    function _transfer(
	        address sender,
	        address recipient,
	        uint256 amount
	    ) internal {
	        require(sender != address(0), 'KRC20: transfer from the zero address');
	        require(recipient != address(0), 'KRC20: transfer to the zero address');
	
	        _balances[sender] = _balances[sender].sub(amount, 'KRC20: transfer amount exceeds balance');
	        _balances[recipient] = _balances[recipient].add(amount);
	        emit Transfer(sender, recipient, amount);
	    }
	
	    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
	     * the total supply.
	     *
	     * Emits a {Transfer} event with `from` set to the zero address.
	     *
	     * Requirements
	     *
	     * - `to` cannot be the zero address.
	     */
	    function _mint(address account, uint256 amount) internal returns(bool) {
	        require(account != address(0), 'KRC20: mint to the zero address');
            require(amount.add(_totalSupply) <= _maxSupply, 'KRC20: exceed _maxSupply');

	        _totalSupply = _totalSupply.add(amount);
	        _balances[account] = _balances[account].add(amount);
	        emit Transfer(address(0), account, amount);
	    }
	
	    /**
	     * @dev Destroys `amount` tokens from `account`, reducing the
	     * total supply.
	     *
	     * Emits a {Transfer} event with `to` set to the zero address.
	     *
	     * Requirements
	     *
	     * - `account` cannot be the zero address.
	     * - `account` must have at least `amount` tokens.
	     */
	    function _burn(address account, uint256 amount) internal {
	        require(account != address(0), 'KRC20: burn from the zero address');
	
	        _balances[account] = _balances[account].sub(amount, 'KRC20: burn amount exceeds balance');
	        _totalSupply = _totalSupply.sub(amount);
	        emit Transfer(account, address(0), amount);
	    }
	
	    /**
	     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
	     *
	     * This is internal function is equivalent to `approve`, and can be used to
	     * e.g. set automatic allowances for certain subsystems, etc.
	     *
	     * Emits an {Approval} event.
	     *
	     * Requirements:
	     *
	     * - `owner` cannot be the zero address.
	     * - `spender` cannot be the zero address.
	     */
	    function _approve(
	        address owner,
	        address spender,
	        uint256 amount
	    ) internal {
	        require(owner != address(0), 'KRC20: approve from the zero address');
	        require(spender != address(0), 'KRC20: approve to the zero address');
	
	        _allowances[owner][spender] = amount;
	        emit Approval(owner, spender, amount);
	    }
	
	    /**
	     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
	     * from the caller's allowance.
	     *
	     * See {_burn} and {_approve}.
	     */
	    function _burnFrom(address account, uint256 amount) internal {
	        _burn(account, amount);
	        _approve(
	            account,
	            _msgSender(),
	            _allowances[account][_msgSender()].sub(amount, 'KRC20: burn amount exceeds allowance')
	        );
	    }
	}
	
	library EnumerableSet {
	    // To implement this library for multiple types with as little code
	    // repetition as possible, we write it in terms of a generic Set type with
	    // bytes32 values.
	    // The Set implementation uses private functions, and user-facing
	    // implementations (such as AddressSet) are just wrappers around the
	    // underlying Set.
	    // This means that we can only create new EnumerableSets for types that fit
	    // in bytes32.
	
	    struct Set {
	        // Storage of set values
	        bytes32[] _values;
	        // Position of the value in the `values` array, plus 1 because index 0
	        // means a value is not in the set.
	        mapping(bytes32 => uint256) _indexes;
	    }
	
	    /**
	     * @dev Add a value to a set. O(1).
	     *
	     * Returns true if the value was added to the set, that is if it was not
	     * already present.
	     */
	    function _add(Set storage set, bytes32 value) private returns (bool) {
	        if (!_contains(set, value)) {
	            set._values.push(value);
	            // The value is stored at length-1, but we add 1 to all indexes
	            // and use 0 as a sentinel value
	            set._indexes[value] = set._values.length;
	            return true;
	        } else {
	            return false;
	        }
	    }
	
	    /**
	     * @dev Removes a value from a set. O(1).
	     *
	     * Returns true if the value was removed from the set, that is if it was
	     * present.
	     */
	    function _remove(Set storage set, bytes32 value) private returns (bool) {
	        // We read and store the value's index to prevent multiple reads from the same storage slot
	        uint256 valueIndex = set._indexes[value];
	
	        if (valueIndex != 0) {
	            // Equivalent to contains(set, value)
	            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
	            // the array, and then remove the last element (sometimes called as 'swap and pop').
	            // This modifies the order of the array, as noted in {at}.
	
	            uint256 toDeleteIndex = valueIndex - 1;
	            uint256 lastIndex = set._values.length - 1;
	
	            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
	            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
	
	            bytes32 lastvalue = set._values[lastIndex];
	
	            // Move the last value to the index where the value to delete is
	            set._values[toDeleteIndex] = lastvalue;
	            // Update the index for the moved value
	            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
	
	            // Delete the slot where the moved value was stored
	            set._values.pop();
	
	            // Delete the index for the deleted slot
	            delete set._indexes[value];
	
	            return true;
	        } else {
	            return false;
	        }
	    }
	
	    /**
	     * @dev Returns true if the value is in the set. O(1).
	     */
	    function _contains(Set storage set, bytes32 value) private view returns (bool) {
	        return set._indexes[value] != 0;
	    }
	
	    /**
	     * @dev Returns the number of values on the set. O(1).
	     */
	    function _length(Set storage set) private view returns (uint256) {
	        return set._values.length;
	    }
	
	    /**
	     * @dev Returns the value stored at position `index` in the set. O(1).
	     *
	     * Note that there are no guarantees on the ordering of values inside the
	     * array, and it may change when more values are added or removed.
	     *
	     * Requirements:
	     *
	     * - `index` must be strictly less than {length}.
	     */
	    function _at(Set storage set, uint256 index) private view returns (bytes32) {
	        require(set._values.length > index, 'EnumerableSet: index out of bounds');
	        return set._values[index];
	    }
	
	    // AddressSet
	
	    struct AddressSet {
	        Set _inner;
	    }
	
	    /**
	     * @dev Add a value to a set. O(1).
	     *
	     * Returns true if the value was added to the set, that is if it was not
	     * already present.
	     */
	    function add(AddressSet storage set, address value) internal returns (bool) {
	        return _add(set._inner, bytes32(uint256(value)));
	    }
	
	    /**
	     * @dev Removes a value from a set. O(1).
	     *
	     * Returns true if the value was removed from the set, that is if it was
	     * present.
	     */
	    function remove(AddressSet storage set, address value) internal returns (bool) {
	        return _remove(set._inner, bytes32(uint256(value)));
	    }
	
	    /**
	     * @dev Returns true if the value is in the set. O(1).
	     */
	    function contains(AddressSet storage set, address value) internal view returns (bool) {
	        return _contains(set._inner, bytes32(uint256(value)));
	    }
	
	    /**
	     * @dev Returns the number of values in the set. O(1).
	     */
	    function length(AddressSet storage set) internal view returns (uint256) {
	        return _length(set._inner);
	    }
	
	    /**
	     * @dev Returns the value stored at position `index` in the set. O(1).
	     *
	     * Note that there are no guarantees on the ordering of values inside the
	     * array, and it may change when more values are added or removed.
	     *
	     * Requirements:
	     *
	     * - `index` must be strictly less than {length}.
	     */
	    function at(AddressSet storage set, uint256 index) internal view returns (address) {
	        return address(uint256(_at(set._inner, index)));
	    }
	
	    // UintSet
	
	    struct UintSet {
	        Set _inner;
	    }
	
	    /**
	     * @dev Add a value to a set. O(1).
	     *
	     * Returns true if the value was added to the set, that is if it was not
	     * already present.
	     */
	    function add(UintSet storage set, uint256 value) internal returns (bool) {
	        return _add(set._inner, bytes32(value));
	    }
	
	    /**
	     * @dev Removes a value from a set. O(1).
	     *
	     * Returns true if the value was removed from the set, that is if it was
	     * present.
	     */
	    function remove(UintSet storage set, uint256 value) internal returns (bool) {
	        return _remove(set._inner, bytes32(value));
	    }
	
	    /**
	     * @dev Returns true if the value is in the set. O(1).
	     */
	    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
	        return _contains(set._inner, bytes32(value));
	    }
	
	    /**
	     * @dev Returns the number of values on the set. O(1).
	     */
	    function length(UintSet storage set) internal view returns (uint256) {
	        return _length(set._inner);
	    }
	
	    /**
	     * @dev Returns the value stored at position `index` in the set. O(1).
	     *
	     * Note that there are no guarantees on the ordering of values inside the
	     * array, and it may change when more values are added or removed.
	     *
	     * Requirements:
	     *
	     * - `index` must be strictly less than {length}.
	     */
	    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
	        return uint256(_at(set._inner, index));
	    }
	}


	// KuSwap token with Governance.
	contract KUSToken is KRC20('KuSwap', 'KUS') {
	    using EnumerableSet for EnumerableSet.AddressSet;
	    EnumerableSet.AddressSet private _minters;
	
	    /// @notice Creates `_amount` token to `_to`.
	    function mint(address _to, uint256 _amount) public onlyMinter returns(bool) {
	        _mint(_to, _amount);
	        _moveDelegates(address(0), _delegates[_to], _amount);
	        return true;
	    }
	
	    // Copied and modified from YAM code:
	    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
	    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
	    // Which is copied and modified from COMPOUND:
	    // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
	
	    /// @dev A record of each accounts delegate
	    mapping (address => address) internal _delegates;
	
	    /// @notice A checkpoint for marking number of votes from a given block
	    struct Checkpoint {
	        uint32 fromBlock;
	        uint256 votes;
	    }
	
	    /// @notice A record of votes checkpoints for each account, by index
	    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
	
	    /// @notice The number of checkpoints for each account
	    mapping (address => uint32) public numCheckpoints;
	
	    /// @notice The EIP-712 typehash for the contract's domain
	    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
	
	    /// @notice The EIP-712 typehash for the delegation struct used by the contract
	    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
	
	    /// @notice A record of states for signing / validating signatures
	    mapping (address => uint) public nonces;
	
	      /// @notice An event thats emitted when an account changes its delegate
	    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
	
	    /// @notice An event thats emitted when a delegate account's vote balance changes
	    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
	
	    /**
	     * @notice Delegate votes from `msg.sender` to `delegatee`
	     * @param delegator The address to get delegatee for
	     */
	    function delegates(address delegator)
	        external
	        view
	        returns (address)
	    {
	        return _delegates[delegator];
	    }
	
	   /**
	    * @notice Delegate votes from `msg.sender` to `delegatee`
	    * @param delegatee The address to delegate votes to
	    */
	    function delegate(address delegatee) external {
	        return _delegate(msg.sender, delegatee);
	    }
	
	    /**
	     * @notice Delegates votes from signatory to `delegatee`
	     * @param delegatee The address to delegate votes to
	     * @param nonce The contract state required to match the signature
	     * @param expiry The time at which to expire the signature
	     * @param v The recovery byte of the signature
	     * @param r Half of the ECDSA signature pair
	     * @param s Half of the ECDSA signature pair
	     */
	    function delegateBySig(
	        address delegatee,
	        uint nonce,
	        uint expiry,
	        uint8 v,
	        bytes32 r,
	        bytes32 s
	    )
	        external
	    {
	        bytes32 domainSeparator = keccak256(
	            abi.encode(
	                DOMAIN_TYPEHASH,
	                keccak256(bytes(name())),
	                getChainId(),
	                address(this)
	            )
	        );
	
	        bytes32 structHash = keccak256(
	            abi.encode(
	                DELEGATION_TYPEHASH,
	                delegatee,
	                nonce,
	                expiry
	            )
	        );
	
	        bytes32 digest = keccak256(
	            abi.encodePacked(
	                "\x19\x01",
	                domainSeparator,
	                structHash
	            )
	        );
	
	        address signatory = ecrecover(digest, v, r, s);
	        require(signatory != address(0), "KUS::delegateBySig: invalid signature");
	        require(nonce == nonces[signatory]++, "KUS::delegateBySig: invalid nonce");
	        require(now <= expiry, "KUS::delegateBySig: signature expired");
	        return _delegate(signatory, delegatee);
	    }
	
	    /**
	     * @notice Gets the current votes balance for `account`
	     * @param account The address to get votes balance
	     * @return The number of current votes for `account`
	     */
	    function getCurrentVotes(address account)
	        external
	        view
	        returns (uint256)
	    {
	        uint32 nCheckpoints = numCheckpoints[account];
	        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
	    }
	
	    /**
	     * @notice Determine the prior number of votes for an account as of a block number
	     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
	     * @param account The address of the account to check
	     * @param blockNumber The block number to get the vote balance at
	     * @return The number of votes the account had as of the given block
	     */
	    function getPriorVotes(address account, uint blockNumber)
	        external
	        view
	        returns (uint256)
	    {
	        require(blockNumber < block.number, "KUS::getPriorVotes: not yet determined");
	
	        uint32 nCheckpoints = numCheckpoints[account];
	        if (nCheckpoints == 0) {
	            return 0;
	        }
	
	        // First check most recent balance
	        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
	            return checkpoints[account][nCheckpoints - 1].votes;
	        }
	
	        // Next check implicit zero balance
	        if (checkpoints[account][0].fromBlock > blockNumber) {
	            return 0;
	        }
	
	        uint32 lower = 0;
	        uint32 upper = nCheckpoints - 1;
	        while (upper > lower) {
	            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
	            Checkpoint memory cp = checkpoints[account][center];
	            if (cp.fromBlock == blockNumber) {
	                return cp.votes;
	            } else if (cp.fromBlock < blockNumber) {
	                lower = center;
	            } else {
	                upper = center - 1;
	            }
	        }
	        return checkpoints[account][lower].votes;
	    }
	
	    function _delegate(address delegator, address delegatee)
	        internal
	    {
	        address currentDelegate = _delegates[delegator];
	        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying KUSs (not scaled);
	        _delegates[delegator] = delegatee;
	
	        emit DelegateChanged(delegator, currentDelegate, delegatee);
	
	        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
	    }
	
	    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
	        if (srcRep != dstRep && amount > 0) {
	            if (srcRep != address(0)) {
	                // decrease old representative
	                uint32 srcRepNum = numCheckpoints[srcRep];
	                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
	                uint256 srcRepNew = srcRepOld.sub(amount);
	                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
	            }
	
	            if (dstRep != address(0)) {
	                // increase new representative
	                uint32 dstRepNum = numCheckpoints[dstRep];
	                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
	                uint256 dstRepNew = dstRepOld.add(amount);
	                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
	            }
	        }
	    }
	
	    function _writeCheckpoint(
	        address delegatee,
	        uint32 nCheckpoints,
	        uint256 oldVotes,
	        uint256 newVotes
	    )
	        internal
	    {
	        uint32 blockNumber = safe32(block.number, "KUS::_writeCheckpoint: block number exceeds 32 bits");
	
	        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
	            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
	        } else {
	            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
	            numCheckpoints[delegatee] = nCheckpoints + 1;
	        }
	
	        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
	    }
	
	    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
	        require(n < 2**32, errorMessage);
	        return uint32(n);
	    }
	
	    function getChainId() internal pure returns (uint) {
	        uint256 chainId;
	        assembly { chainId := chainid() }
	        return chainId;
	    }
	
	
	    function addMinter(address _addMinter) public onlyOwner returns (bool) {
	        require(_addMinter != address(0), "KUS: _addMinter is the zero address");
	        return EnumerableSet.add(_minters, _addMinter);
	    }
	
	    function delMinter(address _delMinter) public onlyOwner returns (bool) {
	        require(_delMinter != address(0), "KUS: _delMinter is the zero address");
	        return EnumerableSet.remove(_minters, _delMinter);
	    }
	
	    function getMinterLength() public view returns (uint256) {
	        return EnumerableSet.length(_minters);
	    }
	
	    function isMinter(address account) public view returns (bool) {
	        return EnumerableSet.contains(_minters, account);
	    }
	
	    function getMinter(uint256 _index) public view onlyOwner returns (address){
	        require(_index <= getMinterLength() - 1, "KUS: index out of bounds");
	        return EnumerableSet.at(_minters, _index);
	    }
	
	    // modifier for mint function
	    modifier onlyMinter() {
	        require(isMinter(msg.sender), "caller is not the minter");
	        _;
	    }
	}
	
	// MasterChef is the master of KUS. He can make KUS and he is a fair guy.
	// Note that it's ownable and the owner wields tremendous power. The ownership
	// will be transferred to a governance smart contract once KUS is sufficiently
	// distributed and the community can show to govern itself.
	// Have fun reading it
	 
     /**
     *  KUSGov interface
     * 
     **/
 	interface KUSGovToken {
    function totalSupply() external view returns (uint256);
    function lockedEnd(address _addr) external view returns (uint256);
    function mintedForLock(address _addr) external view returns (uint256);
	}

    /**
     * Interface for Refferal system
     * 
     **/
    interface IReferral {
		function recordReferralCommission(address referrer, uint256 commission) external;
		function getReferrer(address user) external view returns (address);
        function setCurrentTimestamp(address _user) external;
 		function calculateRefReward(address _user, uint256 _pending) external view returns (uint256);
 	}

	contract MasterKUS is Ownable, ReentrancyGuard {
	    using SafeMath for uint;
	    using SafeMath for uint256;
	    using SafeKRC20 for IKRC20; 
	    // Info of each user.
	    struct UserInfo {
	        uint256 amount; // How many LP tokens the user has provided.
	        uint256 rewardDebt; // Reward debt. See explanation below.
	        // We do some fancy math here. Basically, any point in time, the amount of KUSs
	        // entitled to a user but is pending to be distributed is:
	        //
	        //   pending reward = (user.amount * pool.accKUSPerShare) - user.rewardDebt
	        //
	        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
	        //   1. The pool's `accKUSPerShare` (and `lastRewardBlock`) gets updated.
	        //   2. User receives the pending reward sent to his/her address.
	        //   3. User's `amount` gets updated.
	        //   4. User's `rewardDebt` gets updated.
	    }
	    // Info of each pool.
	    struct PoolInfo {
	        IKRC20 lpToken; // Address of LP token contract.
	        uint256 allocPoint; // How many allocation points assigned to this pool. KUSs to distribute per block.
	        uint256 lastRewardBlock; // Last block number that KUSs distribution occurs.
	        uint256 accKUSPerShare; // Accumulated KUSs per share, times 1e12. See below.
	    }
	    // The KUS TOKEN!
	    KUSToken public immutable KUS;
		// The KuSwap Governance TOKEN!
	    KUSGovToken public immutable KUSGov;
		// The Referral System
        IReferral public Referral;
	    uint256 public constant percentDec = 1000000;
	    //Pools and Farms percent from token per block
	    uint256 public stakingPercent;
	    //Developers percent from token per block
	    uint256 public immutable devPercent;
	      //KuVault fund percent from token per block
	    uint256 public immutable kuVaultPercent;
	    //This will be 100% for Community Contents (com-engagement)
	    uint256 public immutable comPercent;
	    // Dev address.
	    address public devaddr;
	    // KuVault fund.
	    address public immutable kuVaultaddr;
	    address public comAddr;
	    uint256 public lastBlockDevWithdraw;
	    // KUS tokens created per block.
	    uint256 public KUSPerBlock;
	    // Bonus muliplier for early KUS makers.
	    uint256 public BONUS_MULTIPLIER = 1;
 		//! Burn address
    	address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;  
	    // Info of each pool.
	    PoolInfo[] public poolInfo;
	    // Info of each user that stakes LP tokens.
	    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
		mapping(address => bool) public bonusGovActivated;
 		// avoid duplicate KuSwap-LPs
	    mapping(address => bool) lpExist;
 		// Total allocation poitns. Must be the sum of all allocation points in all pools.
	    uint256 public totalAllocPoint = 0;
	    // The block number when KUS mining starts.
	    uint256 public immutable startBlock;
	    // Deposited amount KUS in MasterChef
	    uint256 public depositedKus;
		uint256 public minKUSGovDuration = block.timestamp + 30 days;

    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 ReferralCommissionPaid(address indexed user, address indexed referrer, uint256 newAmount);
    event UpdateMultiplier(uint256 multiplier);
    event SetDevAddress(address dev);
    event SetComAddress(address user);
    event UpdateKusPerBlock(uint256 block);
	    
    modifier PoolValidation(uint256 _pid) {
         require(_pid < poolInfo.length , "Pool does not exist.");
         _;
        }
 	// modifier to check if lockedEnd is higher than current timestamp
	modifier onlyLocker() {
       uint256 lockedEnd = KUSGov.lockedEnd(_msgSender());
		require(KUSGov.mintedForLock(_msgSender()) >= 50 ether, "you have less than 50 KUSGov");
		require(lockedEnd >= minKUSGovDuration, "KUSGov locked is less than 30 days");
		_;
	}

	    constructor(
	        KUSToken _KUS,
	        KUSGovToken _KUSGov,
	        address _devaddr,
	        address _comAddr,
	        address _kuVaultaddr,
	        uint256 _KUSPerBlock,
	        uint256 _startBlock,
	        uint256 _stakingPercent,
	        uint256 _devPercent,
	        uint256 _kuVaultPercent,
	        uint256 _comPercent
	    ) public {
	        KUS = _KUS;
	        KUSGov = _KUSGov;
	        devaddr = _devaddr;
	        comAddr = _comAddr;
	        kuVaultaddr = _kuVaultaddr;
	        KUSPerBlock = _KUSPerBlock;
	        startBlock = _startBlock;
	        stakingPercent = _stakingPercent;
	        devPercent = _devPercent;
	        kuVaultPercent = _kuVaultPercent;
	        comPercent = _comPercent;
	        lastBlockDevWithdraw = _startBlock;
	        uint256 totalPer = _stakingPercent.add(_devPercent).add(_kuVaultPercent).add(_comPercent);
	        require(totalPer == percentDec, "Must total to 1000000");
	        // staking pool
	        poolInfo.push(PoolInfo({
	            lpToken: _KUS,
	            allocPoint: 1000,
	            lastRewardBlock: _startBlock,
	            accKUSPerShare: 0
	        }));
	        totalAllocPoint = 1000;
	    }
	    
	    function updateMultiplier(uint256 multiplierNumber) public onlyOwner {
	        BONUS_MULTIPLIER = multiplierNumber;
            emit UpdateMultiplier(multiplierNumber);
	    }
	
	    function poolLength() external view returns (uint256) {
	        return poolInfo.length;
		}

	    function withdrawDevAndRefFee() public nonReentrant {
	        require(lastBlockDevWithdraw < block.number, 'Not matured yet');
	        uint256 multiplier = getMultiplier(lastBlockDevWithdraw, block.number);
	        uint256 KUSReward = multiplier.mul(KUSPerBlock);
	        KUS.mint(devaddr, KUSReward.mul(devPercent).div(percentDec));
	        KUS.mint(kuVaultaddr, KUSReward.mul(kuVaultPercent).div(percentDec));
	        KUS.mint(comAddr, KUSReward.mul(comPercent).div(percentDec));
	        lastBlockDevWithdraw = block.number;
	    }
	
	    // Add a new lp to the pool. Can only be called by the owner.
	    // Fixed: Do Not add the same LP token more than once. Rewards will be messed up if you do.
	    function add(uint256 _allocPoint, IKRC20 _lpToken) public onlyOwner {
	        require(!lpExist[address(_lpToken)], "Duplicate LP token");
            massUpdatePools();
	        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
	        totalAllocPoint = totalAllocPoint.add(_allocPoint);
	        poolInfo.push(
	            PoolInfo({
	                lpToken: _lpToken,
	                allocPoint: _allocPoint,
	                lastRewardBlock: lastRewardBlock,
	                accKUSPerShare: 0
	            })
	        );
	        lpExist[address(_lpToken)] = true;
	    }
	
	    // Update the given pool's KUS allocation point. Can only be called by the owner.
	    function set( uint256 _pid, uint256 _allocPoint) public onlyOwner PoolValidation(_pid) { 
            massUpdatePools(); 
	        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
	        poolInfo[_pid].allocPoint = _allocPoint;
	    }

		function hasGovBonus(address _addr) public view returns (bool) {
			return KUSGov.mintedForLock(_addr) >= 50 ether;
		}
		// function to check lockedEnd >= minKUSGovDuration
		function isLockedEndMin(address _addr) public view returns (bool) {
			return KUSGov.lockedEnd(_addr) >= minKUSGovDuration;
		}
 
		function hasBonusGovActivated(address _addr) public view returns (bool) {
			return bonusGovActivated[_addr];
		}
 
		function activateGovBonus() public onlyLocker {
			require(!bonusGovActivated[_msgSender()], "Bonus already activated");
			bonusGovActivated[_msgSender()] = true;
		}
 		
		function deactivateGovBonus() public onlyLocker {
			require(bonusGovActivated[_msgSender()], "Bonus already deactivated");
			bonusGovActivated[_msgSender()] = false;
		}

	    // Return reward multiplier over the given _from to _to block.
	    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { 
	         return _to.sub(_from).mul(BONUS_MULTIPLIER);
	    }

		// Function to calculate the bonus for KUSGov.
		function calculateBonus(uint256 pendingReward) internal view returns (uint256) {
			uint256 votingBalance = KUSGov.mintedForLock(_msgSender());
			uint256 votingTotal = KUSGov.totalSupply();
			uint bonus = pendingReward.mul(150).mul(votingBalance).mul(10**5).div(votingTotal).div(10**7);
			return bonus;
		}

	    // View function to see pending KUS on frontend.
	    function pendingKUS(uint256 _pid, address _user) external PoolValidation(_pid) view returns (uint256) {
	        PoolInfo storage pool = poolInfo[_pid];
	        UserInfo storage user = userInfo[_pid][_user];
	        uint256 accKUSPerShare = pool.accKUSPerShare;
	        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
	        if (_pid == 0){
	            lpSupply = depositedKus;
	        } 
	        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
	            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
				uint256 KUSReward = multiplier.mul(KUSPerBlock).mul(pool.allocPoint).mul(stakingPercent).div(totalAllocPoint).div(percentDec);
	            accKUSPerShare = accKUSPerShare.add(KUSReward.mul(1e12).div(lpSupply)); 
        	}
			uint256 pendingReward =  user.amount.mul(accKUSPerShare).div(1e12).sub(user.rewardDebt);
			
			if (hasGovBonus(_msgSender()) && isLockedEndMin(_msgSender()) && bonusGovActivated[_msgSender()]) { 
			uint256 bonusForKusGov = calculateBonus(pendingReward);
			uint256 reward = pendingReward.add(bonusForKusGov);
 			return reward;
			 } else {
				return pendingReward; 
			 }
        }

	    // Update reward vairables for all pools. Be careful of gas spending!
	    function massUpdatePools() public {
	        uint256 length = poolInfo.length;
	        for (uint256 pid = 0; pid < length; ++pid) {
	            updatePool(pid);
	        }
	    }
		
        function payReferralCommission(address _user, uint256 _pending) internal {
        if (address(Referral) != address(0)) {
            address userRef = Referral.getReferrer(_user);
			if (userRef != address(0)) { 
				// upto 5% of the pending KUS
			 	uint256 comission = Referral.calculateRefReward(_user, _pending);
				 // safety check
				 if (comission < _pending) {
					KUS.mint(address(userRef), comission);
					Referral.recordReferralCommission(userRef, comission);
					emit ReferralCommissionPaid(_user, userRef, comission);
				 }
			}  
        }
    }
	
	    // Update reward variables of the given pool to be up-to-date.
	  function updatePool(uint256 _pid) public PoolValidation(_pid) {
		PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (_pid == 0){
            lpSupply = depositedKus;
        }
        if (lpSupply <= 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 KUSReward = multiplier.mul(KUSPerBlock).mul(pool.allocPoint).mul(stakingPercent).div(totalAllocPoint).div(percentDec);
		// Automatically burn 2% of minted tokens
        KUS.mint(BURN_ADDRESS, KUSReward.mul(20).div(1000));
        KUS.mint(address(this), KUSReward);
        pool.accKUSPerShare = pool.accKUSPerShare.add(KUSReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

	    // Deposit LP tokens to MasterChef for KUS allocation.
	    function deposit(uint256 _pid, uint256 _amount) external PoolValidation(_pid) nonReentrant  {
	        require (_pid != 0, 'deposit KUS by staking');
	        PoolInfo storage pool = poolInfo[_pid];
	        UserInfo storage user = userInfo[_pid][msg.sender];
	        updatePool(_pid);
	        if (user.amount > 0) {	
	            uint256 pending = user.amount.mul(pool.accKUSPerShare).div(1e12).sub(user.rewardDebt);
				if (hasGovBonus(_msgSender()) && isLockedEndMin(_msgSender()) && bonusGovActivated[_msgSender()]) { 
					uint256 bonusForKusGov = calculateBonus(pending);
					uint256 reward = pending.add(bonusForKusGov);
					KUS.mint(address(this), bonusForKusGov);
					safeKUSTransfer(msg.sender, reward);
			 	} else {
 					safeKUSTransfer(msg.sender, pending);
				 }
 				payReferralCommission(msg.sender, pending);
	        }

            if(_amount > 0 ) {
	        pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
	        user.amount = user.amount.add(_amount);
            }

 			if (address(Referral) != address(0) && _amount > 0) {
            Referral.setCurrentTimestamp(msg.sender);
		    }

	        user.rewardDebt = user.amount.mul(pool.accKUSPerShare).div(1e12);
	        emit Deposit(msg.sender, _pid, _amount);
	    }
	
	    // Withdraw LP tokens from MasterChef.
	    function withdraw(uint256 _pid, uint256 _amount) external PoolValidation(_pid) nonReentrant {
	        require (_pid != 0, 'withdraw KUS by unstaking');
	        PoolInfo storage pool = poolInfo[_pid];
	        UserInfo storage user = userInfo[_pid][msg.sender];
	        require(user.amount >= _amount, "withdraw: not good");
	        updatePool(_pid);
	        uint256 pending = user.amount.mul(pool.accKUSPerShare).div(1e12).sub(user.rewardDebt); 
			if (hasGovBonus(_msgSender()) && isLockedEndMin(_msgSender()) && bonusGovActivated[_msgSender()]) { 
					uint256 bonusForKusGov = calculateBonus(pending);
					uint256 reward = pending.add(bonusForKusGov);
					KUS.mint(address(this), bonusForKusGov);
					safeKUSTransfer(msg.sender, reward);
 			} else {
		  	       safeKUSTransfer(msg.sender, pending);
			 }

            if(_amount > 0) {
                user.amount = user.amount.sub(_amount);
 				payReferralCommission(msg.sender, pending);
                pool.lpToken.safeTransfer(address(msg.sender), _amount);
            }

 			if (address(Referral) != address(0) && _amount > 0) {
          		Referral.setCurrentTimestamp(msg.sender);
		    }

	        user.rewardDebt = user.amount.mul(pool.accKUSPerShare).div(1e12);
	        emit Withdraw(msg.sender, _pid, _amount);
	    }
	
	        // Stake KUS tokens to MasterChef
	    function enterStaking(uint256 _amount) external PoolValidation(0) nonReentrant   {
	        PoolInfo storage pool = poolInfo[0];
	        UserInfo storage user = userInfo[0][msg.sender];
	        updatePool(0);
	        if (user.amount > 0) {
	            uint256 pending = user.amount.mul(pool.accKUSPerShare).div(1e12).sub(user.rewardDebt);
	            if(pending > 0) {
					if (hasGovBonus(_msgSender()) && isLockedEndMin(_msgSender()) && bonusGovActivated[_msgSender()]) { 
					uint256 bonusForKusGov = calculateBonus(pending);
					uint256 reward = pending.add(bonusForKusGov);
					KUS.mint(address(this), bonusForKusGov);
					safeKUSTransfer(msg.sender, reward);
			 		} else {
						safeKUSTransfer(msg.sender, pending);
					 }
 					payReferralCommission(msg.sender, pending);
	            }  
	        }
	        if(_amount > 0) {
	            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
	            user.amount = user.amount.add(_amount);
	            depositedKus = depositedKus.add(_amount);
	        }
			
 			if (address(Referral) != address(0) && _amount > 0) {
 				Referral.setCurrentTimestamp(msg.sender);
		    }

	        user.rewardDebt = user.amount.mul(pool.accKUSPerShare).div(1e12);
	        emit Deposit(msg.sender, 0, _amount);
	    }
	
	    // Withdraw KUS tokens from STAKING.
	    function leaveStaking(uint256 _amount) external PoolValidation(0) nonReentrant   {
	        PoolInfo storage pool = poolInfo[0];
	        UserInfo storage user = userInfo[0][msg.sender];
	        require(user.amount >= _amount, "withdraw: not good");
	        updatePool(0);
	        uint256 pending = user.amount.mul(pool.accKUSPerShare).div(1e12).sub(user.rewardDebt);
	        if(pending > 0) {
				if (hasGovBonus(_msgSender()) && isLockedEndMin(_msgSender()) && bonusGovActivated[_msgSender()]) { 
					uint256 bonusForKusGov = calculateBonus(pending);
					uint256 reward = pending.add(bonusForKusGov);
					KUS.mint(address(this), bonusForKusGov);
					safeKUSTransfer(msg.sender, reward);
			 	} else {
		            safeKUSTransfer(msg.sender, pending);
				 }
		 			payReferralCommission(msg.sender, pending);
	        }
	        if(_amount > 0) {
	            user.amount = user.amount.sub(_amount);
	            pool.lpToken.safeTransfer(address(msg.sender), _amount);
	            depositedKus = depositedKus.sub(_amount);
	        }
			
 			if (address(Referral) != address(0) && _amount > 0) {
            Referral.setCurrentTimestamp(msg.sender);
		    }

	        user.rewardDebt = user.amount.mul(pool.accKUSPerShare).div(1e12);
	        emit Withdraw(msg.sender, 0, _amount);
	    }
	
	    // Want to withdraw without caring about KUS rewards? EMERGENCY ONLY.
	    function emergencyWithdraw(uint256 _pid) external PoolValidation(_pid) nonReentrant   {
	        PoolInfo storage pool = poolInfo[_pid];
	        UserInfo storage user = userInfo[_pid][msg.sender];
	        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
	        if(_pid == 0) {
	            depositedKus = depositedKus.sub(user.amount);
	        }
 			if (address(Referral) != address(0)) {
            Referral.setCurrentTimestamp(msg.sender);
		    }
	        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
	        user.amount = 0;
	        user.rewardDebt = 0;
	    }
	
	    // Safe KUS transfer function, just in case if rounding error causes pool to not have enough KUSs.
	    function safeKUSTransfer(address _to, uint256 _amount) internal {
	        uint256 KUSBal = KUS.balanceOf(address(this));
	        if (_amount > KUSBal) {
	            KUS.transfer(_to, KUSBal);
	        } else {
	            KUS.transfer(_to, _amount);
	        }
	    }
	
	    function setDevAddress(address _devaddr) public onlyOwner {
	        devaddr = _devaddr;
            emit SetDevAddress(_devaddr);
	    }
	     function setComAddress(address _comaddr) public onlyOwner {
	        comAddr = _comaddr;
            emit SetComAddress(_comaddr);
	    }

	    function updateKusPerBlock(uint256 newAmount) public onlyOwner {
	        require(newAmount <= 30 * 1e18, 'Max per block 30 KUS');
	        KUSPerBlock = newAmount;
            emit UpdateKusPerBlock(newAmount);
	    }

         function setReferralSystem(address _address) public onlyOwner {
	        require(_address != address(0), 'Address(0) not allowed');
	        Referral = IReferral(_address);
	    }
	
	}