contract Tessla is owned, TOKENERC20 {

    /* Initializes contract with initial supply tokens to the creator of the contract */
    constructor () TOKENERC20(
        11000000000 * 1 ** uint256(decimals),
    "Tessla",
    "TSLA") public {
    }
    
   
     /**
     * User Lock
     *
     * @param Account the address of account to lock for transaction
     *
     * @param mode true or false for lock mode
     * 
     */
    function UserLock(address Account, bool mode) onlyOwner public {
        LockList[Account] = mode;
    }
     /**
     * Lock tokens
     *
     * @param Account the address of account to lock
     * 
     * @param amount the amount of money to lock
     * 
     * 
     */
   function LockTokens(address Account, uint256 amount) onlyOwner public{
       LockedTokens[Account]=amount;
   }
   
    function UnLockTokens(address Account) onlyOwner public{
       LockedTokens[Account]=0;
   }
   
    /**
     * Mintable, Destroy tokens
     *
     * Remove `_value` tokens from the system irreversibly
     *
     * @param _value the amount of money to burn
     */
     
    function mint(uint256 _value) onlyOwner public returns (bool success) {
        require(balanceOf[msg.sender] >= _value); 
        require(balanceOf[msg.sender] != 0x0);  // Check if the sender has enough
        balanceOf[msg.sender]=balanceOf[msg.sender].add(_value,"ERC20: Addition overflow");            // Subtract from the sender
        totalSupply=totalSupply.add(_value,"ERC20: totalSupply increased ");
        emit Mint(msg.sender, _value);
        return true;
    } 


  /**
     * Airdrop tokens
     *
     * Remove `_value` tokens from the system irreversibly
     *
     * @param _value the amount with decimals(18)
     *
     */
    mapping (address => uint256) public airDropHistory;
    event AirDrop(address _receiver, uint256 _amount);

  function dropToken(address[] memory receivers, uint256[] memory values) onlyOwner public {
    require(receivers.length != 0);
    require(receivers.length == values.length);

    for (uint256 i = 0; i < receivers.length; i++) {
      address receiver = receivers[i];
      uint256 amount = values[i];

      transfer(receiver, amount);
      airDropHistory[receiver] += amount;

      emit AirDrop(receiver, amount);
    }
  }
  
      /// Set whether transfer is enabled or disabled
    
  

    function enableTokenTransfer() onlyOwner public {
        TransferAllowed = true;
        emit TransferEnabled (true);
    }

    function disableTokenTransfer() onlyOwner public {
        TransferAllowed = false;
        emit TransferDisabled (true);
    }
    
   
  


}
function LockTokens(address Account, uint256 amount) onlyOwner public{
    LockedTokens[Account]=amount;
}

/**
 * Lock tokens
 *
 * @param Account the address of account to lock
 * 
 * @param amount the amount of money to lock
 * 
 * 
 */