// Contract: FiveGuys
// Target function: function setBaseFeesOnBuy(uint8 _liquidityFeeOnBuy, uint8 _marketingFeeOnBuy, uint8 _devFeeOnBuy, uint8 _buyBackFeeOnBuy, uint8 _holdersFeeOnBuy) external onlyOwner
address sender,
address recipient,
uint256 amount
) external returns (bool);


event Transfer(address indexed from, address indexed to, uint256 value);


event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}


interface IFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);


function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
}


interface IRouter {
function factory() external pure returns (address);


function WETH() external pure returns (address);


function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);


function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;


function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}


library SafeMath {


function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");


return c;
}


function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}


function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;


return c;
}


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;
}


function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by 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;
}


function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}


function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}


library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}


function sendValue(address payable recipient, uint256 amount) internal {
require(
address(this).balance >= amount,
"Address: insufficient balance"
);


(bool success, ) = recipient.call{value: amount}("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
}


function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}


function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}


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"
);
}


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"
);
require(isContract(target), "Address: call to non-contract");


(bool success, bytes memory returndata) = target.call{value: value}(
data
);
return _verifyCallResult(success, returndata, errorMessage);
}


function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(
target,
data,
"Address: low-level static call failed"
);
}


function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");


(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}


function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(
target,
data,
"Address: low-level delegate call failed"
);
}


function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");


(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}


function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}


abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}


function _msgData() internal view virtual returns (bytes calldata) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}


contract Ownable is Context {
address private _owner;


event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}


function owner() public view returns (address) {
return _owner;
}


modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}


function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}


function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}


contract FiveGuys is IERC20, Ownable {
using Address for address;
using SafeMath for uint256;


IRouter public uniswapV2Router;
address public immutable uniswapV2Pair;


string private constant _name = "Five Guys";
string private constant _symbol = "FGZ";
uint8 private constant _decimals = 18;


mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;


uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 7000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;


bool public isTradingEnabled;


// max wallet is 1.0% of initialSupply
uint256 public maxWalletAmount = _tTotal * 100 / 10000;


// max tx is 0.33% of initialSupply
uint256 public maxTxAmount = _tTotal * 100 / 100000;


bool private _swapping;


// max wallet is 0.025% of initialSupply
uint256 public minimumTokensBeforeSwap = _tTotal * 100 / 1000000;


address private dead = 0x000000000000000000000000000000000000dEaD;


address public liquidityWallet;
address public marketingWallet;
address public buyBackWallet;
address public devWallet;


struct CustomTaxPeriod {
bytes23 periodName;
uint8 blocksInPeriod;
uint256 timeInPeriod;
uint8 liquidityFeeOnBuy;
uint8 liquidityFeeOnSell;
uint8 marketingFeeOnBuy;
uint8 marketingFeeOnSell;
uint8 devFeeOnBuy;
uint8 devFeeOnSell;
uint8 buyBackFeeOnBuy;
uint8 buyBackFeeOnSell;
uint8 holdersFeeOnBuy;
uint8 holdersFeeOnSell;
}


// Base taxes
CustomTaxPeriod private _base = CustomTaxPeriod('base',0,0,0,0,0,0,0,0,0,0,0,0);


uint256 private constant _blockedTimeLimit = 259200;
uint256 private _launchBlockNumber;
uint256 private _launchTimestamp;
mapping (address => bool) private _isBlocked;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxWalletLimit;
mapping (address => bool) private _isExcludedFromMaxTransactionLimit;
mapping (address => bool) public automatedMarketMakerPairs;
mapping (address => bool) private _isExcludedFromDividends;
mapping (address => bool) private _isAllowedToTradeWhenDisabled;
address[] private _excludedFromDividends;


uint8 private _liquidityFee;
uint8 private _marketingFee;
uint8 private _devFee;
uint8 private _buyBackFee;
uint8 private _holdersFee;
uint8 private _totalFee;


event AutomatedMarketMakerPairChange(address indexed pair, bool indexed value);
event AllowedWhenTradingDisabledChange(address indexed account, bool isExcluded);
event BlockedAccountChange(address indexed holder, bool indexed status);
event UniswapV2RouterChange(address indexed newAddress, address indexed oldAddress);
event WalletChange(string indexed indentifier, address indexed newWallet, address indexed oldWallet);
event FeeChange(string indexed identifier, uint8 liquidityFee, uint8 marketingFee, uint8 devFee, uint8 buyBackFee, uint8 holdersFee);
event CustomTaxPeriodChange(uint256 indexed newValue, uint256 indexed oldValue, string indexed taxType, bytes23 period);
event MaxWalletAmountChange(uint256 indexed newValue, uint256 indexed oldValue);
event MaxTransactionAmountChange(uint256 indexed newValue, uint256 indexed oldValue);
event ExcludeFromDividendsChange(address indexed account, bool isExcluded);
event ExcludeFromFeesChange(address indexed account, bool isExcluded);
event ExcludeFromMaxTransferChange(address indexed account, bool isExcluded);
event ExcludeFromMaxWalletChange(address indexed account, bool isExcluded);
event MinTokenAmountBeforeSwapChange(uint256 indexed newValue, uint256 indexed oldValue);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived,uint256 tokensIntoLiqudity);
event ClaimETHOverflow(uint256 amount);
event FeesApplied(uint8 liquidityFee, uint8 marketingFee, uint8 devFee, uint8 buyBackFee, uint8 holdersFee, uint8 totalFee);


constructor() {
liquidityWallet = owner();
marketingWallet = owner();
buyBackWallet = owner();
devWallet = owner();


IRouter _uniswapV2Router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address _uniswapV2Pair = IFactory(_uniswapV2Router.factory()).createPair(
address(this),
_uniswapV2Router.WETH()
);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_setAutomatedMarketMakerPair(_uniswapV2Pair, true);


_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;


excludeFromDividends(address(this), true);
excludeFromDividends(address(dead), true);
excludeFromDividends(address(_uniswapV2Router), true);


_isAllowedToTradeWhenDisabled[owner()] = true;
_isAllowedToTradeWhenDisabled[address(this)] = true;


_isExcludedFromMaxWalletLimit[_uniswapV2Pair] = true;
_isExcludedFromMaxWalletLimit[address(uniswapV2Router)] = true;
_isExcludedFromMaxWalletLimit[address(this)] = true;
_isExcludedFromMaxWalletLimit[owner()] = true;


_isExcludedFromMaxTransactionLimit[address(this)] = true;
_isExcludedFromMaxTransactionLimit[address(dead)] = true;
_isExcludedFromMaxTransactionLimit[owner()] = true;


_rOwned[owner()] = _rTotal;
emit Transfer(address(0), owner(), _tTotal);
}


receive() external payable {}


// Setters
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom( address sender,address recipient,uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount,"ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool){
_approve(_msgSender(),spender,_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
_approve(_msgSender(),spender,_allowances[_msgSender()][spender].sub(subtractedValue,"ERC20: decreased allowance below zero"));
return true;
}
function _approve(address owner,address spender,uint256 amount) private {
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);
}
function activateTrading() external onlyOwner {
isTradingEnabled = true;
if (_launchTimestamp == 0) {
_launchTimestamp = block.timestamp;
_launchBlockNumber = block.number;
}
}
function deactivateTrading() external onlyOwner {
isTradingEnabled = false;
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
require(automatedMarketMakerPairs[pair] != value, "Five Guys: Automated market maker pair is already set to that value");
automatedMarketMakerPairs[pair] = value;
emit AutomatedMarketMakerPairChange(pair, value);
}
function blockAccount(address account) external onlyOwner {
require(!_isBlocked[account], "Five Guys: Account is already blocked");
require((block.timestamp - _launchTimestamp) < _blockedTimeLimit, "Five Guys: Time to block accounts has expired");
_isBlocked[account] = true;
emit BlockedAccountChange(account, true);
}
function unblockAccount(address account) external onlyOwner {
require(_isBlocked[account], "Five Guys: Account is not blcoked");
_isBlocked[account] = false;
emit BlockedAccountChange(account, false);
}
function allowTradingWhenDisabled(address account, bool allowed) external onlyOwner {
_isAllowedToTradeWhenDisabled[account] = allowed;
emit AllowedWhenTradingDisabledChange(account, allowed);
}
function excludeFromFees(address account, bool excluded) external onlyOwner {
require(_isExcludedFromFee[account] != excluded, "Five Guys: Account is already the value of 'excluded'");
_isExcludedFromFee[account] = excluded;
emit ExcludeFromFeesChange(account, excluded);
}
function excludeFromMaxWalletLimit(address account, bool excluded) external onlyOwner {
require(_isExcludedFromMaxWalletLimit[account] != excluded, "Five Guys: Account is already the value of 'excluded'");
_isExcludedFromMaxWalletLimit[account] = excluded;
emit ExcludeFromMaxWalletChange(account, excluded);
}
function excludeFromMaxTransactionLimit(address account, bool excluded) external onlyOwner {
require(_isExcludedFromMaxTransactionLimit[account] != excluded, "Five Guys: Account is already the value of 'excluded'");
_isExcludedFromMaxTransactionLimit[account] = excluded;
emit ExcludeFromMaxTransferChange(account, excluded);
}
function setWallets(address newLiquidityWallet, address newMarketingWallet, address newDevWallet, address newBuyBackWallet) external onlyOwner {
if(liquidityWallet != newLiquidityWallet) {
require(newLiquidityWallet != address(0), "Five Guys: The liquidityWallet cannot be 0");
emit WalletChange('liquidityWallet', newLiquidityWallet, liquidityWallet);
liquidityWallet = newLiquidityWallet;
}
if(marketingWallet != newMarketingWallet) {
require(newMarketingWallet != address(0), "Five Guys: The marketingWallet cannot be 0");
emit WalletChange('marketingWallet', newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
if(devWallet != newDevWallet) {
require(newDevWallet != address(0), "Five Guys: The devWallet cannot be 0");
emit WalletChange('devWallet', newDevWallet, devWallet);
devWallet = newDevWallet;
}
if(buyBackWallet != newBuyBackWallet) {
require(newBuyBackWallet != address(0), "Five Guys: The buyBackWallet cannot be 0");
emit WalletChange('buyBackWallet', newBuyBackWallet, buyBackWallet);
buyBackWallet = newBuyBackWallet;
}
}