// SPDX-License-Identifier: MIT

// ______ _______ __ ______
// / \| \| \ / \
// | ▓▓▓▓▓▓\ ▓▓▓▓▓▓▓\ ▓▓ | ▓▓▓▓▓▓\
// | ▓▓__| ▓▓ ▓▓__/ ▓▓ ▓▓ | ▓▓ \▓▓
// | ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ | ▓▓
// | ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓\ ▓▓ | ▓▓ __
// | ▓▓ | ▓▓ ▓▓__/ ▓▓ ▓▓_____| ▓▓__/ \
// | ▓▓ | ▓▓ ▓▓ ▓▓ ▓▓ \\▓▓ ▓▓
// \▓▓ \▓▓\▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓▓ \▓▓▓▓▓▓

pragma solidity ^0.8.0;

interface BEP20 {
function totalSupply() external view returns (uint256);

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

function transfer(address recipient, 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 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);
event botAddedToBlacklist(address account);
event botRemovedFromBlacklist(address account);

}
pragma solidity ^0.8.0;
contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
}



pragma solidity ^0.8.0;


interface BEP20Metadata is BEP20 {

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

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

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

pragma solidity ^0.8.0;

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

pragma solidity ^0.8.0;


contract ERC20 is Context, BEP20, BEP20Metadata, ReentrancyGuard {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => bool) public _isBlackListedBot;

using SafeMath for uint256;
uint256 private _totalSupply;
string private _name;
string private _symbol;

constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}

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

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

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

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

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

function transfer(address recipient, uint256 amount) public virtual override nonReentrant returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}

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

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

function transferFrom(address sender, address recipient, uint256 amount) public virtual override nonReentrant returns (bool) {
_transfer(sender, recipient, amount);

uint256 currentAllowance = _allowances[sender][_msgSender()];
require(!_isBlackListedBot[sender], "Account is blacklisted");
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);

return true;
}

function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] addedValue);
return true;
}

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

return true;
}

function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(!_isBlackListedBot[sender], "Account is blacklisted");
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");

_beforeTokenTransfer(sender, recipient, amount);

uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] = amount;

emit Transfer(sender, recipient, amount);
}


function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
require(!_isBlackListedBot[account], "Account is blacklisted");
_beforeTokenTransfer(address(0), account, amount);

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

function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
require(!_isBlackListedBot[account], "Account is blacklisted");
_beforeTokenTransfer(account, address(0), amount);

uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;

emit Transfer(account, address(0), amount);
}


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");
require(!_isBlackListedBot[spender], "Account is blacklisted");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}

function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

pragma solidity ^0.8.0;


abstract contract ERC20Burnable is Context, ERC20 {

function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}

function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), currentAllowance - amount);
_burn(account, amount);
}
}




pragma solidity ^0.8.0;

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) {

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;

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


pragma solidity ^0.8.0;

library Address {

function isContract(address account) internal view returns (bool) {

uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}

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

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

// solhint-disable-next-line avoid-low-level-calls
(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");

// solhint-disable-next-line avoid-low-level-calls
(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");

// solhint-disable-next-line avoid-low-level-calls
(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 {
// 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);
}
}
}
}


pragma solidity ^0.8.0;

interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


pragma solidity ^0.8.0;


abstract contract ERC165 is IERC165 {

function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}

pragma solidity ^0.8.0;

interface IERC1363 is BEP20, IERC165 {

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

function transferAndCall(
address recipient,
uint256 amount,
bytes calldata data
) external returns (bool);

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


function transferFromAndCall(
address sender,
address recipient,
uint256 amount,
bytes calldata data
) external returns (bool);

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

function approveAndCall(
address spender,
uint256 amount,
bytes calldata data
) external returns (bool);
}

pragma solidity ^0.8.0;


interface IERC1363Receiver {
function onTransferReceived(
address operator,
address sender,
uint256 amount,
bytes calldata data
) external returns (bytes4);
}

pragma solidity ^0.8.0;

interface IERC1363Spender {
function onApprovalReceived(
address sender,
uint256 amount,
bytes calldata data
) external returns (bytes4);
}

pragma solidity ^0.8.0;

abstract contract ERC1363 is ERC20, IERC1363, ERC165 {
using Address for address;

function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC1363).interfaceId || super.supportsInterface(interfaceId);
}

function transferAndCall(address recipient, uint256 amount) public virtual override returns (bool) {
return transferAndCall(recipient, amount, "");
}

function transferAndCall(
address recipient,
uint256 amount,
bytes memory data
) public virtual override returns (bool) {
transfer(recipient, amount);
require(_checkAndCallTransfer(_msgSender(), recipient, amount, data), "ERC1363: _checkAndCallTransfer reverts");
return true;
}

function transferFromAndCall(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
return transferFromAndCall(sender, recipient, amount, "");
}


function transferFromAndCall(
address sender,
address recipient,
uint256 amount,
bytes memory data
) public virtual override returns (bool) {
transferFrom(sender, recipient, amount);
require(_checkAndCallTransfer(sender, recipient, amount, data), "ERC1363: _checkAndCallTransfer reverts");
return true;
}

function approveAndCall(address spender, uint256 amount) public virtual override returns (bool) {
return approveAndCall(spender, amount, "");
}

function approveAndCall(
address spender,
uint256 amount,
bytes memory data
) public virtual override returns (bool) {
approve(spender, amount);
require(_checkAndCallApprove(spender, amount, data), "ERC1363: _checkAndCallApprove reverts");
return true;
}

function _checkAndCallTransfer(
address sender,
address recipient,
uint256 amount,
bytes memory data
) internal virtual returns (bool) {
if (!recipient.isContract()) {
return false;
}
bytes4 retval = IERC1363Receiver(recipient).onTransferReceived(_msgSender(), sender, amount, data);
return (retval == IERC1363Receiver(recipient).onTransferReceived.selector);
}

function _checkAndCallApprove(
address spender,
uint256 amount,
bytes memory data
) internal virtual returns (bool) {
if (!spender.isContract()) {
return false;
}
bytes4 retval = IERC1363Spender(spender).onApprovalReceived(_msgSender(), amount, data);
return (retval == IERC1363Spender(spender).onApprovalReceived.selector);
}
}

pragma solidity ^0.8.0;

abstract contract Ownable is Context {
address public _owner;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

function owner() public view virtual 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;
}
}

pragma solidity ^0.8.0;

contract TokenRecover is Ownable {

function recoverERC20(address tokenAddress, uint256 tokenAmount) public virtual onlyOwner {
BEP20(tokenAddress).transfer(owner(), tokenAmount);
}
}

pragma solidity ^0.8.0;

abstract contract ERC20Decimals is ERC20 {
uint8 private immutable _decimals;

constructor(uint8 decimals_) {
_decimals = decimals_;
}

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

pragma solidity ^0.8.0;

abstract contract ERC20Mintable is ERC20 {
// indicates if minting is finished
bool private _mintingFinished = false;

event MintFinished();

modifier canMint() {
require(!_mintingFinished, "ERC20Mintable: minting is finished");
_;
}

function mintingFinished() external view returns (bool) {
return _mintingFinished;
}

function mint(address account, uint256 amount) external canMint {
_mint(account, amount);
}

function finishMinting() external canMint {
_finishMinting();
}

function _finishMinting() internal virtual {
_mintingFinished = true;

emit MintFinished();
}
}

pragma solidity ^0.8.0;

contract ABLC is ERC20Decimals, ERC20Mintable, ERC20Burnable, ERC1363, TokenRecover {
using SafeMath for uint256;
constructor(
string memory name_,
string memory symbol_,
uint8 decimals_,
uint256 initialBalance_,
address tokenOwner
) payable ERC20(name_, symbol_) ERC20Decimals(decimals_) {
_owner = tokenOwner;
_mint(tokenOwner, initialBalance_*10**uint256(decimals_));

}

//admin functions
function addUserToBlacklist(address account) external onlyOwner {
require(!_isBlackListedBot[account], "Account is already blacklisted");
_isBlackListedBot[account] = true;

emit botAddedToBlacklist(account);
}

function removeUserFromBlacklist(address account) external onlyOwner {
require(_isBlackListedBot[account], "Account is not blacklisted");
_isBlackListedBot[account] = false;
emit botRemovedFromBlacklist(account);
}

function decimals() public view virtual override(ERC20, ERC20Decimals) returns (uint8) {
return super.decimals();
}

function _mint(address account, uint256 amount) internal override onlyOwner{
super._mint(account, amount);
}

function _finishMinting() internal override onlyOwner{
super._finishMinting();
}
}