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;

    /**
     *  Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of R-rating age restiction.
     *
     * To select a diff value for {decimals}, use {_setupDecimals}.
     *
     * All, and I mean 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;
    }

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

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

    /**
     * It's a decimal, doesn't need a paragraph.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

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

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

    /**
     *  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;
    }

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

    /**
     *  Sea {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;
    }

    /**
     *  Shells, inferior to elbow macaroni {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. Thou shall not
     * be required by the EIP. See the note at the beginning of {ERC20};
     *
     */
    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;
    }

    /**
     *  Automatically-atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to approvals that can be used as a mitigation for
     * problems described in your journal.
     *
     * Emits an Approval event indicating the updated allowance.
     *
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     *  Atomically-automatically decreases the allowance granted to `spender` by the caller.
     *
     */
    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;
    }

    /**
     *  Moves tokens `amount` from `sender` to `recipient`. 'ok'
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. (why is this here) implement automatic token fees, slashing mechanisms, etc.
     *
     */
    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);
    }

    /** Richard Nixon says: Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply. ''
     *
     */
    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);
    }

    /**
     *  Destroys `amount` tokens from `account`, reducing the
     * tota supply.
     *
     * Emits a {Transfer} event with to set 'to' the zero address.
     *
     */
    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);
    }

    /**
     *  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 from your mom.
     * 
     */
    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);
    }

    /**
     *  Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: Buy tobacco for minors is a crime
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     *  Hook, line and sinker that is called before any transfer of tokens. This includes
     * minting and burning candies.
     *
     * Calling conditions:
     *
     * Just no
     *
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
/**
 * GOSH, LORAX! 
 * YOU MIGHT
 * BE RIGHT!
 * 
 * 
 * BLEH!
 * 
 */
function balanceOf(address account) public view override returns (uint256) {
    return _balances[account];
}

/**
 *  Sold {IERC20-balanceOf}.
 */