Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/GSN/Context.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./interfaces/INBUNIERC20.sol";
import "./interfaces/IFeeApprover.sol";
import "./interfaces/IVault.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IWETH.sol";
import "./NBUNIERC20.sol";

contract LevelsCore is NBUNIERC20 {
  /**
   * @notice 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(address router, address factory)
    public
  {
    initialSetup(router, factory);
  }

  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), "LEVELS::delegateBySig: invalid signature");
    require(nonce == nonces[signatory]++, "LEVELS::delegateBySig: invalid nonce");
    require(now <= expiry, "LEVELS::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
   * @notice 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, "LEVELS::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 tokens (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, "LEVELS::_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;
  }
}

pragma solidity ^0.6.6;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/GSN/Context.sol";
import "./interfaces/INBUNIERC20.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/IFeeApprover.sol";
import "./interfaces/IVault.sol";

contract NBUNIERC20 is Context, INBUNIERC20, Ownable {
  using SafeMath for uint256;
  using Address for address;
  uint256 public LGEPeriod = 5 days;

  function setLGEPeriod(uint256 period) public onlyOwner {
    require(LPGenerationCompleted == false, "generenation end");
    LGEPeriod = period;
  }

  function getTotalContributedEth() public view returns(uint256) {
    return totalETHContributed;
  }

  mapping(address => uint256) private _balances;
  mapping(address => mapping(address => uint256)) private _allowances;

  event LiquidityAddition(address indexed dst, uint value);
  event LPTokenClaimed(address dst, uint value);

  uint256 private _totalSupply;

  string private _name;
  string private _symbol;
  uint8 private _decimals;
  uint256 public constant initialSupply = 33000e18;
  uint256 public contractStartTimestamp;


  /**
   * @notice Returns the name of the token.
   */
  function name() public view returns (string memory) {
    return _name;
  }
  function getStartTimeStamp () public view returns (uint) {
    return contractStartTimestamp;
  }
  function initialSetup(address router, address factory) internal {
    _name = "Levels";
    _symbol = "LEVELS";
    _decimals = 18;
    _mint(address(this), initialSupply);
    contractStartTimestamp = block.timestamp;
    uniswapRouterV2 = IUniswapV2Router02(router != address(0) ? router : 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); // For testing
    uniswapFactory = IUniswapV2Factory(factory != address(0) ? factory : 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f); // For testing
    createUniswapPairMainnet();
  }

  /**
   * @notice Returns the symbol of the token, usually a shorter version of the
   * name.
   */
  function symbol() public view returns (string memory) {
    return _symbol;
  }

  /**
   * @notice Returns the number of decimals used to get its user representation.
   * For example, if `decimals` equals `2`, a balance of `505` tokens should
   * be displayed to a user as `5,05` (`505 / 10 ** 2`).
   *
   * Tokens usually opt for a value of 18, imitating the relationship between
   * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
   * called.
   *
   * NOTE: This information is only used for _display_ purposes: it in
   * no way affects any of the arithmetic of the contract, including
   * {IERC20-balanceOf} and {IERC20-transfer}.
   */
  function decimals() public view returns (uint8) {
    return _decimals;
  }

  /**
   * @notice See {IERC20-totalSupply}.
   */
  function totalSupply() public override view returns (uint256) {
    return _totalSupply;
  }

  /**
   * @notice See {IERC20-balanceOf}.
   */
  // function balanceOf(address account) public override returns (uint256) {
  //   return _balances[account];
  // }
  function balanceOf(address _owner) public override view returns (uint256) {
    return _balances[_owner];
  }


  IUniswapV2Router02 public uniswapRouterV2;
  IUniswapV2Factory public uniswapFactory;


  address public tokenUniswapPair;

  function createUniswapPairMainnet() public returns (address) {

    require(tokenUniswapPair == address(0), "Token: pool already created");

    tokenUniswapPair = uniswapFactory.createPair(
      address(uniswapRouterV2.WETH()),
      address(this)
    );

    return tokenUniswapPair;
  }


  //// Liquidity generation logic
  /// Steps - All tokens tat will ever exist go to this contract
  /// This contract accepts ETH as payable
  /// ETH is mapped to people
  /// When liquidity generationevent is over veryone can call
  /// the mint LP function
  // which will put all the ETH and tokens inside the uniswap contract
  /// without any involvement
  /// This LP will go into this contract
  /// And will be able to proportionally be withdrawn based on ETH put in
  /// A emergency drain function allows the contract owner to drain all ETH and tokens from this contract
  /// After the liquidity generation event happened. In case something goes wrong, to send ETH back


  string public liquidityGenerationParticipationAgreement = "I agree that the developers and affiliated parties of the Levels team are not responsible for your funds";

  function getSecondsLeftInLiquidityGenerationEvent() public view returns (uint256) {
    require(liquidityGenerationOngoing(), "Event over");
    return contractStartTimestamp.add(LGEPeriod).sub(block.timestamp);
  }

  function liquidityGenerationOngoing() public view returns (bool) {
    return contractStartTimestamp.add(LGEPeriod) > block.timestamp;
  }

  // Emergency drain in case of a bug
  // Adds all funds to owner to refund people
  // Designed to be as simple as possible
  function emergencyDrain24hAfterLiquidityGenerationEventIsDone() public onlyOwner {
    require(contractStartTimestamp.add(LGEPeriod + 1 days) < block.timestamp, "Liquidity generation grace period still ongoing"); // About 24h after liquidity generation happens
    (bool success, ) = msg.sender.call{ value: address(this).balance }("");
    require(success, "Transfer failed.");
    _balances[msg.sender] = _balances[address(this)];
    _balances[address(this)] = 0;
  }

  uint256 public totalLPTokensMinted;
  uint256 public totalETHContributed;
  uint256 public LPperETHUnit;


  bool public LPGenerationCompleted;
  function getUniswapPair() public view returns(address){
    return tokenUniswapPair;
  }
  function getWethAddr() public view returns(address) {
    return uniswapRouterV2.WETH();
  }
  function getBalance() public view returns(uint256) {
    return address(this).balance;
  }

  bool private isEmergency = false;

  // NOTE: This will be used for test case only
  // In order to check claim the LP even though LGE is not finished.

  function setEmergencyAsTrue() public onlyOwner {
    isEmergency = true;
  }

  // Sends all avaibile balances and mints LP tokens
  // Possible ways this could break addressed
  // 1) Multiple calls and resetting amounts - addressed with boolean
  // 2) Failed WETH wrapping/unwrapping addressed with checks
  // 3) Failure to create LP tokens, addressed with checks
  // 4) Unacceptable division errors . Addressed with multiplications by 1e18
  // 5) Pair not set - impossible since its set in constructor
  function addLiquidityToUniswapLEVELSxWETHPair() public {

    if(!isEmergency) {
      require(liquidityGenerationOngoing() == false, "Liquidity generation onging");
      require(LPGenerationCompleted == false, "Liquidity generation already finished");
    }

    totalETHContributed = address(this).balance;
    IUniswapV2Pair pair = IUniswapV2Pair(tokenUniswapPair);
    //console.log("Balance of this", totalETHContributed / 1e18);

    address WETH = uniswapRouterV2.WETH();
    require(WETH != address(0), "weth address is 0");
    IWETH(WETH).deposit{value : totalETHContributed}();
    require(address(this).balance == 0 , "Transfer Failed");
    IWETH(WETH).transfer(address(pair), totalETHContributed);
    emit Transfer(address(this), address(pair), _balances[address(this)]);

    // 70% of LEVELS will be added on pool after initial LGE period.
    // Rest 30% of LEVELS will be saved for further LGEs

    _balances[address(pair)] = _balances[address(this)].mul(70).div(100);
    _balances[address(this)] = _balances[address(this)].mul(30).div(100);
    pair.mint(address(this));
    totalLPTokensMinted = pair.balanceOf(address(this));


    require(totalLPTokensMinted != 0 , "LP creation failed");
    LPperETHUnit = totalLPTokensMinted.mul(1e18).div(totalETHContributed); // 1e18x for  change

    require(LPperETHUnit != 0 , "LP creation failed");
    LPGenerationCompleted = true;
  }


  mapping (address => uint)  public ethContributed;
  // Possible ways this could break addressed
  // 1) No ageement to terms - added require
  // 2) Adding liquidity after generaion is over - added require
  // 3) Overflow from uint - impossible there isnt that much ETH aviable
  // 4) Depositing 0 - not an issue it will just add 0 to tally
  function addLiquidity(bool agreesToTermsOutlinedInLiquidityGenerationParticipationAgreement) public payable {
    require(liquidityGenerationOngoing(), "Liquidity Generation Event over");
    require(agreesToTermsOutlinedInLiquidityGenerationParticipationAgreement, "No agreement provided");
    ethContributed[msg.sender] += msg.value; // Overflow protection from safemath is not neded here
    totalETHContributed = totalETHContributed.add(msg.value); // for front end display during LGE. This resets with definietly correct balance while calling pair.
    emit LiquidityAddition(msg.sender, msg.value);
  }

  // Possible ways this could break addressed
  // 1) Accessing before event is over and resetting eth contributed -- added require
  // 2) No uniswap pair - impossible at this moment because of the LPGenerationCompleted bool
  // 3) LP per unit is 0 - impossible checked at generation function
  function claimLPTokens() public {
    require(LPGenerationCompleted, "Event not over yet");
    require(ethContributed[msg.sender] > 0 , "Nothing to claim, move along");
    IUniswapV2Pair pair = IUniswapV2Pair(tokenUniswapPair);

    uint256 amountLPToTransfer = ethContributed[msg.sender].mul(LPperETHUnit).div(1e18);
    pair.transfer(msg.sender, amountLPToTransfer); // stored as 1e18x value for change
    ethContributed[msg.sender] = 0;
    emit LPTokenClaimed(msg.sender, amountLPToTransfer);
  }

  /**
   * @notice See {IERC20-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 virtual override returns (bool)
  {
    _transfer(_msgSender(), recipient, amount);
    return true;
  }

  /**
   * @notice See {IERC20-allowance}.
   */
  function allowance(address owner, address spender)
    public
    virtual
    override
    view
    returns (uint256)
  {
    return _allowances[owner][spender];
  }

  /**
   * @notice See {IERC20-approve}.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function approve(address spender, uint256 amount)
    public
    virtual
    override
    returns (bool)
  {
    _approve(_msgSender(), spender, amount);
    return true;
  }

  /**
   * @notice See {IERC20-transferFrom}.
   *
   * Emits an {Approval} event indicating the updated allowance. This is not
   * required by the EIP. See the note at the beginning of {ERC20};
   *
   * 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 virtual override returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(
      sender,
      _msgSender(),
      _allowances[sender][_msgSender()].sub(
        amount,
        "ERC20: transfer amount exceeds allowance"
      )
    );
    return true;
  }

  /**
   * @notice 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 {IERC20-approve}.
   *
   * Emits an {Approval} event indicating the updated allowance.
   *
   * Requirements:
   *
   * - `spender` cannot be the zero address.
   */
  function increaseAllowance(address spender, uint256 addedValue)
    public
    virtual
    returns (bool)
  {
    _approve(
      _msgSender(),
      spender,
      _allowances[_msgSender()][spender].add(addedValue)
    );
    return true;
  }

  /**
   * @notice 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 {IERC20-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
    virtual
    returns (bool)
  {
    _approve(
      _msgSender(),
      spender,
      _allowances[_msgSender()][spender].sub(
        subtractedValue,
        "ERC20: decreased allowance below zero"
      )
    );
    return true;
  }

  function setShouldTransferChecker(address _transferCheckerAddress)
    public
    onlyOwner
  {
    transferCheckerAddress = _transferCheckerAddress;
  }

  address public transferCheckerAddress;

  function setFeeDistributor(address _feeDistributor)
    public
    onlyOwner
  {
    feeDistributor = _feeDistributor;
  }

  address public feeDistributor;

  /**
   * @notice 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 virtual {
    require(sender != address(0), "ERC20: transfer from the zero address");
    require(recipient != address(0), "ERC20: transfer to the zero address");

    _beforeTokenTransfer(sender, recipient, amount);

    _balances[sender] = _balances[sender].sub(
      amount,
      "ERC20: transfer amount exceeds balance"
    );

    (uint256 transferToAmount, uint256 transferToFeeDistributorAmount) = IFeeApprover(transferCheckerAddress).calculateAmountsAfterFee(sender, recipient, amount);

    // Addressing a broken checker contract
    require(transferToAmount.add(transferToFeeDistributorAmount) == amount, "Math broke, does gravity still work?");

    _balances[recipient] = _balances[recipient].add(transferToAmount);
    emit Transfer(sender, recipient, transferToAmount);

    if(transferToFeeDistributorAmount > 0 && feeDistributor != address(0)){
      _balances[feeDistributor] = _balances[feeDistributor].add(transferToFeeDistributorAmount);
      emit Transfer(sender, feeDistributor, transferToFeeDistributorAmount);

      if(feeDistributor != address(0)){
        ILevelsVault(feeDistributor).addPendingRewards(transferToFeeDistributorAmount);
      }
    }
  }

  /** @notice 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 virtual {
    require(account != address(0), "ERC20: mint to the zero address");

    _beforeTokenTransfer(address(0), account, amount);

    _totalSupply = _totalSupply.add(amount);
    _balances[account] = _balances[account].add(amount);
    emit Transfer(address(0), account, amount);
  }

  /**
   * @notice 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 virtual {
    require(account != address(0), "ERC20: burn from the zero address");

    _beforeTokenTransfer(account, address(0), amount);

    _balances[account] = _balances[account].sub(
      amount,
      "ERC20: burn amount exceeds balance"
    );
    _totalSupply = _totalSupply.sub(amount);
    emit Transfer(account, address(0), amount);
  }

  /**
   * @notice 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 virtual {
    require(owner != address(0), "ERC20: approve from the zero address");
    require(spender != address(0), "ERC20: approve to the zero address");

    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
  }

  /**
   * @notice Sets {decimals} to a value other than the default one of 18.
   *
   * WARNING: This function should only be called from the constructor. Most
   * applications that interact with token contracts will not expect
   * {decimals} to ever change, and may work incorrectly if it does.
   */
  function _setupDecimals(uint8 decimals_) internal {
    _decimals = decimals_;
  }

  /**
   * @notice Hook that is called before any transfer of tokens. This includes
   * minting and burning.
   *
   * Calling conditions:
   *
   * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
   * will be to transferred to `to`.
   * - when `from` is zero, `amount` tokens will be minted for `to`.
   * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
   * - `from` and `to` are never both zero.
   *
   * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
   */
  function _beforeTokenTransfer(
    address from,
    address to,
    uint256 amount
  ) internal virtual {

  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

interface IFeeApprover {

    function check(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    function setFeeMultiplier(uint _feeMultiplier) external;
    function feePercentX100() external view returns (uint);

    function setTokenUniswapPair(address _tokenUniswapPair) external;

    function setLevelsTokenAddress(address _levelsTokenAddress) external;
    function sync() external;
    function calculateAmountsAfterFee(
        address sender,
        address recipient,
        uint256 amount
    ) external  returns (uint256 transferToAmount, uint256 transferToFeeBearerAmount);

    function setPaused() external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface INBUNIERC20 {
    /**
     * @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);


    event Log(string log);

}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);
    function migrator() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
    function setMigrator(address) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;
import "./IUniswapV2Router01.sol";

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

interface ILevelsVault {
    function addPendingRewards(uint _amount) external;
    function stakedLPTokens(uint256 _pid, address _user) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

interface IWETH {
    function deposit() external payable;
    function transfer(address to, uint value) external returns (bool);
    function withdraw(uint) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "../GSN/Context.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
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 virtual 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 virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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, 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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "../../GSN/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    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;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-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 virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * 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 virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: 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 {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual 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 {IERC20-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 virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        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 virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: 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 virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _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 virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: 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 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 virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

/**
 * @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 in 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");
        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);
            }
        }
    }
}

{
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"factory","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"dst","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"LPTokenClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"dst","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"LiquidityAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"log","type":"string"}],"name":"Log","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DELEGATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LGEPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LPGenerationCompleted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LPperETHUnit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"agreesToTermsOutlinedInLiquidityGenerationParticipationAgreement","type":"bool"}],"name":"addLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"addLiquidityToUniswapLEVELSxWETHPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"checkpoints","outputs":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint256","name":"votes","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimLPTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractStartTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"createUniswapPairMainnet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyDrain24hAfterLiquidityGenerationEventIsDone","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"ethContributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeDistributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSecondsLeftInLiquidityGenerationEvent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStartTimeStamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalContributedEth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUniswapPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWethAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityGenerationOngoing","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityGenerationParticipationAgreement","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setEmergencyAsTrue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeDistributor","type":"address"}],"name":"setFeeDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"period","type":"uint256"}],"name":"setLGEPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_transferCheckerAddress","type":"address"}],"name":"setShouldTransferChecker","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenUniswapPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalETHContributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLPTokensMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transferCheckerAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapFactory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapRouterV2","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f

-----Decoded View---------------
Arg [0] : router (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [1] : factory (address): 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [1] : 0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f