BscScan - Sponsored slots available. Book your slot here!
[ Download CSV Export ]
OVERVIEW
VAULT is the token of the VAULT ecosystem designed to act as a community bank. Whenever a transaction occurs 4% of the amount is split amongst all VAULT holders and paid out instantly.Contract Name:
BEP20TOKEN
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at BscScan.com on 2021-03-25 */ /** * Submitted for verification at BscScan.com on 26-03-2021 */ pragma solidity 0.6.12; // SPDX-License-Identifier: MIT // ---------------------------------------------------------------------------- // VAULT Token //` // Utilizing RFI Breakthroughs to create a Community Bank and Ecosystem for // Binance Smart Chain // // ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- // Context // ---------------------------------------------------------------------------- // abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode return msg.data; } } // ---------------------------------------------------------------------------- // Ownable // ---------------------------------------------------------------------------- // contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // ---------------------------------------------------------------------------- // Address // ---------------------------------------------------------------------------- // library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ 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"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ 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"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ 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"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); 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); } } } } /** * @dev Interface of the IBEP20 standard. */ // ---------------------------------------------------------------------------- // IBEP20 Interface // ---------------------------------------------------------------------------- // interface IBEP20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the token decimals. */ function decimals() external view returns (uint8); /** * @dev Returns the token symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the token name. */ function name() external view returns (string memory); /** * @dev Returns the bep token owner. */ function getOwner() external view returns (address); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // ---------------------------------------------------------------------------- // Safe Math Library // ---------------------------------------------------------------------------- /** * @title SafeMath * @dev Math operations with safety checks that throw on error */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ 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; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be 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; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // ---------------------------------------------------------------------------- // Token // ---------------------------------------------------------------------------- // contract BEP20TOKEN is Context, IBEP20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; address[] private _excluded; uint256 private constant MAX = ~uint256(0); uint256 private constant _tTotal = 4 * 10**6 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _trustFeeTotal; string private _name = 'VAULT Token'; string private _symbol = 'VAULT'; uint8 private _decimals = 9; address private _trust; constructor () public { _rOwned[_msgSender()] = _rTotal; emit Transfer(address(0), _msgSender(), _tTotal); } function getOwner() external override view returns (address) { return owner(); } function changeTrustAddr(address payable NewTrust) external onlyOwner { _trust = NewTrust; } function getTrustAddr() public view returns(address) { return _trust; } function name() public override view returns (string memory) { return _name; } function symbol() public override view returns (string memory) { return _symbol; } function decimals() public override view returns (uint8) { return _decimals; } function totalSupply() public override view returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalTrustFees() public view returns (uint256) { return _trustFeeTotal; } function reflect(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "BEP20: approve from the zero address"); require(spender != address(0), "BEP20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "BEP20: transfer from the zero address"); require(recipient != address(0), "BEP20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); (uint256 _amount, uint256 _tsend) = _getTrustValues(amount); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, _amount); _transferFromExcludedTrust(sender, _trust, _tsend); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, _amount); _transferToExcludedTrust(sender, _trust, _tsend); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, _amount); _transferStandardTrust(sender, _trust, _tsend); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, _amount); _transferBothExcludedTrust(sender, _trust, _tsend); } else { _transferStandard(sender, recipient, _amount); _transferStandardTrust(sender, _trust, _tsend); } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferStandardTrust(address sender, address recipient, uint256 tAmount) private { _transferStandard(sender, recipient, tAmount); _trustFeeCounter(tAmount); } function _transferToExcludedTrust(address sender, address recipient, uint256 tAmount) private { _transferToExcluded(sender, recipient, tAmount); _trustFeeCounter(tAmount); } function _transferFromExcludedTrust(address sender, address recipient, uint256 tAmount) private { _transferFromExcluded(sender, recipient, tAmount); _trustFeeCounter(tAmount); } function _transferBothExcludedTrust(address sender, address recipient, uint256 tAmount) private { _transferBothExcluded(sender, recipient, tAmount); _trustFeeCounter(tAmount); } function _trustFeeCounter(uint256 Fee) private { uint256 _Add = _getFCValues(Fee); _trustFeeTotal = _trustFeeTotal.add(_Add); } function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee); } function _getTrustValues(uint256 Amount) private pure returns (uint256, uint256) { uint256 bFee = Amount.div(320); uint256 bTransferAmount = Amount.sub(bFee); return (bTransferAmount, bFee); } function _getFCValues(uint256 Amount) private pure returns (uint256) { uint256 bFee = Amount.div(25); uint256 FCAmount = Amount.sub(bFee); return (FCAmount); } function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) { uint256 tFee = tAmount.div(25); uint256 tTransferAmount = tAmount.sub(tFee); return (tTransferAmount, tFee); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } }
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"NewTrust","type":"address"}],"name":"changeTrustAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTrustAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"includeAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcluded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tAmount","type":"uint256"}],"name":"reflect","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tAmount","type":"uint256"},{"internalType":"bool","name":"deductTransferFee","type":"bool"}],"name":"reflectionFromToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"rAmount","type":"uint256"}],"name":"tokenFromReflection","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalTrustFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed ByteCode Sourcemap
17646:12476:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21119:376;;;;;;;;;;;;;;;;-1:-1:-1;21119:376:0;;:::i;:::-;;18870:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19809:161;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;19809:161:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;20920:87;;;:::i;:::-;;;;;;;;;;;;;;;;19174:95;;;:::i;19978:313::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;19978:313:0;;;;;;;;;;;;;;;;;:::i;21945:253::-;;;;;;;;;;;;;;;;-1:-1:-1;21945:253:0;;:::i;19074:92::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;20299:218;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;20299:218:0;;;;;;;;:::i;21503:434::-;;;;;;;;;;;;;;;;-1:-1:-1;21503:434:0;;;;;;;;;:::i;21015:96::-;;;:::i;18777:85::-;;;:::i;:::-;;;;-1:-1:-1;;;;;18777:85:0;;;;;;;;;;;;;;19277:198;;;;;;;;;;;;;;;;-1:-1:-1;19277:198:0;-1:-1:-1;;;;;19277:198:0;;:::i;2255:148::-;;;:::i;18663:106::-;;;;;;;;;;;;;;;;-1:-1:-1;18663:106:0;-1:-1:-1;;;;;18663:106:0;;:::i;18561:94::-;;;:::i;1613:79::-;;;:::i;18970:96::-;;;:::i;20525:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;20525:269:0;;;;;;;;:::i;19483:167::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;19483:167:0;;;;;;;;:::i;20802:110::-;;;;;;;;;;;;;;;;-1:-1:-1;20802:110:0;-1:-1:-1;;;;;20802:110:0;;:::i;19658:143::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;19658:143:0;;;;;;;;;;:::i;22206:332::-;;;;;;;;;;;;;;;;-1:-1:-1;22206:332:0;-1:-1:-1;;;;;22206:332:0;;:::i;2558:244::-;;;;;;;;;;;;;;;;-1:-1:-1;2558:244:0;-1:-1:-1;;;;;2558:244:0;;:::i;22546:478::-;;;;;;;;;;;;;;;;-1:-1:-1;22546:478:0;-1:-1:-1;;;;;22546:478:0;;:::i;21119:376::-;21171:14;21188:12;:10;:12::i;:::-;-1:-1:-1;;;;;21220:19:0;;;;;;:11;:19;;;;;;21171:29;;-1:-1:-1;21220:19:0;;21219:20;21211:77;;;;-1:-1:-1;;;21211:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21300:15;21323:19;21334:7;21323:10;:19::i;:::-;-1:-1:-1;;;;;;;;;21371:15:0;;;;;;:7;:15;;;;;;21299:43;;-1:-1:-1;21371:28:0;;21299:43;21371:19;:28::i;:::-;-1:-1:-1;;;;;21353:15:0;;;;;;:7;:15;;;;;:46;21420:7;;:20;;21432:7;21420:11;:20::i;:::-;21410:7;:30;21464:10;;:23;;21479:7;21464:14;:23::i;:::-;21451:10;:36;-1:-1:-1;;;21119:376:0:o;18870:92::-;18949:5;18942:12;;;;;;;;-1:-1:-1;;18942:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18916:13;;18942:12;;18949:5;;18942:12;;18949:5;18942:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18870:92;:::o;19809:161::-;19884:4;19901:39;19910:12;:10;:12::i;:::-;19924:7;19933:6;19901:8;:39::i;:::-;-1:-1:-1;19958:4:0;19809:161;;;;;:::o;20920:87::-;20989:10;;20920:87;:::o;19174:95::-;18123:17;19174:95;:::o;19978:313::-;20076:4;20093:36;20103:6;20111:9;20122:6;20093:9;:36::i;:::-;20140:121;20149:6;20157:12;:10;:12::i;:::-;20171:89;20209:6;20171:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20171:19:0;;;;;;:11;:19;;;;;;20191:12;:10;:12::i;:::-;-1:-1:-1;;;;;20171:33:0;;;;;;;;;;;;-1:-1:-1;20171:33:0;;;:89;:37;:89::i;:::-;20140:8;:121::i;:::-;-1:-1:-1;20279:4:0;19978:313;;;;;:::o;21945:253::-;22011:7;22050;;22039;:18;;22031:73;;;;-1:-1:-1;;;22031:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22115:19;22138:10;:8;:10::i;:::-;22115:33;-1:-1:-1;22166:24:0;:7;22115:33;22166:11;:24::i;:::-;22159:31;;;21945:253;;;;:::o;19074:92::-;19149:9;;;;19074:92;:::o;20299:218::-;20387:4;20404:83;20413:12;:10;:12::i;:::-;20427:7;20436:50;20475:10;20436:11;:25;20448:12;:10;:12::i;:::-;-1:-1:-1;;;;;20436:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;20436:25:0;;;:34;;;;;;;;;;;:38;:50::i;21503:434::-;21593:7;18123:17;21621:7;:18;;21613:62;;;;;-1:-1:-1;;;21613:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21691:17;21686:244;;21726:15;21749:19;21760:7;21749:10;:19::i;:::-;-1:-1:-1;21725:43:0;;-1:-1:-1;21783:14:0;;-1:-1:-1;;;;21783:14:0;21686:244;21832:23;21862:19;21873:7;21862:10;:19::i;:::-;-1:-1:-1;21830:51:0;;-1:-1:-1;21896:22:0;;-1:-1:-1;;;;21896:22:0;21015:96;21089:14;;21015:96;:::o;18777:85::-;18848:6;;;;;-1:-1:-1;;;;;18848:6:0;;18777:85::o;19277:198::-;-1:-1:-1;;;;;19367:20:0;;19343:7;19367:20;;;:11;:20;;;;;;;;19363:49;;;-1:-1:-1;;;;;;19396:16:0;;;;;;:7;:16;;;;;;19389:23;;19363:49;-1:-1:-1;;;;;19450:16:0;;;;;;:7;:16;;;;;;19430:37;;:19;:37::i;2255:148::-;1835:12;:10;:12::i;:::-;1825:6;;-1:-1:-1;;;;;1825:6:0;;;:22;;;1817:67;;;;;-1:-1:-1;;;1817:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1817:67:0;;;;;;;;;;;;;;;2362:1:::1;2346:6:::0;;2325:40:::1;::::0;-1:-1:-1;;;;;2346:6:0;;::::1;::::0;2325:40:::1;::::0;2362:1;;2325:40:::1;2393:1;2376:19:::0;;-1:-1:-1;;;;;;2376:19:0::1;::::0;;2255:148::o;18663:106::-;1835:12;:10;:12::i;:::-;1825:6;;-1:-1:-1;;;;;1825:6:0;;;:22;;;1817:67;;;;;-1:-1:-1;;;1817:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1817:67:0;;;;;;;;;;;;;;;18744:6:::1;:17:::0;;-1:-1:-1;;;;;18744:17:0;;::::1;;;-1:-1:-1::0;;;;;;18744:17:0;;::::1;::::0;;;::::1;::::0;;18663:106::o;18561:94::-;18613:7;18640;:5;:7::i;:::-;18633:14;;18561:94;:::o;1613:79::-;1651:7;1678:6;-1:-1:-1;;;;;1678:6:0;1613:79;:::o;18970:96::-;19051:7;19044:14;;;;;;;;-1:-1:-1;;19044:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19018:13;;19044:14;;19051:7;;19044:14;;19051:7;19044:14;;;;;;;;;;;;;;;;;;;;;;;;20525:269;20618:4;20635:129;20644:12;:10;:12::i;:::-;20658:7;20667:96;20706:15;20667:96;;;;;;;;;;;;;;;;;:11;:25;20679:12;:10;:12::i;:::-;-1:-1:-1;;;;;20667:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;20667:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;19483:167::-;19561:4;19578:42;19588:12;:10;:12::i;:::-;19602:9;19613:6;19578:9;:42::i;20802:110::-;-1:-1:-1;;;;;20884:20:0;20860:4;20884:20;;;:11;:20;;;;;;;;;20802:110::o;19658:143::-;-1:-1:-1;;;;;19766:18:0;;;19739:7;19766:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;19658:143::o;22206:332::-;1835:12;:10;:12::i;:::-;1825:6;;-1:-1:-1;;;;;1825:6:0;;;:22;;;1817:67;;;;;-1:-1:-1;;;1817:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1817:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;22288:20:0;::::1;;::::0;;;:11:::1;:20;::::0;;;;;::::1;;22287:21;22279:61;;;::::0;;-1:-1:-1;;;22279:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;;;;;22354:16:0;::::1;22373:1;22354:16:::0;;;:7:::1;:16;::::0;;;;;:20;22351:108:::1;;-1:-1:-1::0;;;;;22430:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;22410:37:::1;::::0;:19:::1;:37::i;:::-;-1:-1:-1::0;;;;;22391:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;:56;22351:108:::1;-1:-1:-1::0;;;;;22469:20:0::1;;::::0;;;:11:::1;:20;::::0;;;;:27;;-1:-1:-1;;22469:27:0::1;22492:4;22469:27:::0;;::::1;::::0;;;22507:9:::1;:23:::0;;;;::::1;::::0;;;;;;::::1;::::0;;-1:-1:-1;;;;;;22507:23:0::1;::::0;;::::1;::::0;;22206:332::o;2558:244::-;1835:12;:10;:12::i;:::-;1825:6;;-1:-1:-1;;;;;1825:6:0;;;:22;;;1817:67;;;;;-1:-1:-1;;;1817:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1817:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;2647:22:0;::::1;2639:73;;;;-1:-1:-1::0;;;2639:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2749:6;::::0;;2728:38:::1;::::0;-1:-1:-1;;;;;2728:38:0;;::::1;::::0;2749:6;::::1;::::0;2728:38:::1;::::0;::::1;2777:6;:17:::0;;-1:-1:-1;;;;;;2777:17:0::1;-1:-1:-1::0;;;;;2777:17:0;;;::::1;::::0;;;::::1;::::0;;2558:244::o;22546:478::-;1835:12;:10;:12::i;:::-;1825:6;;-1:-1:-1;;;;;1825:6:0;;;:22;;;1817:67;;;;;-1:-1:-1;;;1817:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1817:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;22627:20:0;::::1;;::::0;;;:11:::1;:20;::::0;;;;;::::1;;22619:60;;;::::0;;-1:-1:-1;;;22619:60:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;22695:9;22690:327;22714:9;:16:::0;22710:20;::::1;22690:327;;;22772:7;-1:-1:-1::0;;;;;22756:23:0::1;:9;22766:1;22756:12;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;22756:12:0::1;:23;22752:254;;;22815:9;22825:16:::0;;-1:-1:-1;;22825:20:0;;;22815:31;::::1;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;22800:9:::1;:12:::0;;-1:-1:-1;;;;;22815:31:0;;::::1;::::0;22810:1;;22800:12;::::1;;;;;;::::0;;;::::1;::::0;;;;;;::::1;:46:::0;;-1:-1:-1;;;;;;22800:46:0::1;-1:-1:-1::0;;;;;22800:46:0;;::::1;;::::0;;22865:16;;::::1;::::0;;:7:::1;:16:::0;;;;;;:20;;;22904:11:::1;:20:::0;;;;:28;;-1:-1:-1;;22904:28:0::1;::::0;;22951:9:::1;:15:::0;;;::::1;;;;;::::0;;;::::1;::::0;;;;-1:-1:-1;;22951:15:0;;;;;-1:-1:-1;;;;;;22951:15:0::1;::::0;;;;;22985:5:::1;;22752:254;22732:3;;22690:327;;;;22546:478:::0;:::o;634:106::-;722:10;634:106;:::o;27964:411::-;28023:7;28032;28041;28050;28059;28080:23;28105:12;28121:20;28133:7;28121:11;:20::i;:::-;28079:62;;;;28152:19;28175:10;:8;:10::i;:::-;28152:33;;28197:15;28214:23;28239:12;28255:39;28267:7;28276:4;28282:11;28255;:39::i;:::-;28196:98;;;;-1:-1:-1;28196:98:0;;-1:-1:-1;28345:15:0;;-1:-1:-1;28362:4:0;;-1:-1:-1;27964:411:0;;-1:-1:-1;;;;;;27964:411:0:o;13473:136::-;13531:7;13558:43;13562:1;13565;13558:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;13551:50;13473:136;-1:-1:-1;;;13473:136:0:o;13009:181::-;13067:7;13099:5;;;13123:6;;;;13115:46;;;;;-1:-1:-1;;;13115:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;23032:337;-1:-1:-1;;;;;23125:19:0;;23117:68;;;;-1:-1:-1;;;23117:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23204:21:0;;23196:68;;;;-1:-1:-1;;;23196:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23277:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;23329:32;;;;;;;;;;;;;;;;;23032:337;;;:::o;23377:1331::-;-1:-1:-1;;;;;23474:20:0;;23466:70;;;;-1:-1:-1;;;23466:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23555:23:0;;23547:71;;;;-1:-1:-1;;;23547:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23646:1;23637:6;:10;23629:64;;;;-1:-1:-1;;;23629:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23705:15;23722:14;23740:23;23756:6;23740:15;:23::i;:::-;-1:-1:-1;;;;;23788:19:0;;;;;;:11;:19;;;;;;23704:59;;-1:-1:-1;23704:59:0;-1:-1:-1;23788:19:0;;:46;;;;-1:-1:-1;;;;;;23812:22:0;;;;;;:11;:22;;;;;;;;23811:23;23788:46;23784:917;;;23851:49;23873:6;23881:9;23892:7;23851:21;:49::i;:::-;23950:6;;23915:50;;23942:6;;23950;;;-1:-1:-1;;;;;23950:6:0;23958;23915:26;:50::i;:::-;23784:917;;;-1:-1:-1;;;;;23988:19:0;;;;;;:11;:19;;;;;;;;23987:20;:46;;;;-1:-1:-1;;;;;;24011:22:0;;;;;;:11;:22;;;;;;;;23987:46;23983:718;;;24050:47;24070:6;24078:9;24089:7;24050:19;:47::i;:::-;24145:6;;24112:48;;24137:6;;24145;;;-1:-1:-1;;;;;24145:6:0;24153;24112:24;:48::i;23983:718::-;-1:-1:-1;;;;;24183:19:0;;;;;;:11;:19;;;;;;;;24182:20;:47;;;;-1:-1:-1;;;;;;24207:22:0;;;;;;:11;:22;;;;;;;;24206:23;24182:47;24178:523;;;24246:45;24264:6;24272:9;24283:7;24246:17;:45::i;:::-;24337:6;;24306:46;;24329:6;;24337;;;-1:-1:-1;;;;;24337:6:0;24345;24306:22;:46::i;24178:523::-;-1:-1:-1;;;;;24374:19:0;;;;;;:11;:19;;;;;;;;:45;;;;-1:-1:-1;;;;;;24397:22:0;;;;;;:11;:22;;;;;;;;24374:45;24370:331;;;24436:49;24458:6;24466:9;24477:7;24436:21;:49::i;:::-;24535:6;;24500:50;;24527:6;;24535;;;-1:-1:-1;;;;;24535:6:0;24543;24500:26;:50::i;24370:331::-;24583:45;24601:6;24609:9;24620:7;24583:17;:45::i;:::-;24674:6;;24643:46;;24666:6;;24674;;;-1:-1:-1;;;;;24674:6:0;24682;24643:22;:46::i;:::-;23377:1331;;;;;:::o;13912:192::-;13998:7;14034:12;14026:6;;;;14018:29;;;;-1:-1:-1;;;14018:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;14070:5:0;;;13912:192::o;29387:163::-;29428:7;29449:15;29466;29485:19;:17;:19::i;:::-;29448:56;;-1:-1:-1;29448:56:0;-1:-1:-1;29522:20:0;29448:56;;29522:11;:20::i;:::-;29515:27;;;;29387:163;:::o;15310:132::-;15368:7;15395:39;15399:1;15402;15395:39;;;;;;;;;;;;;;;;;:3;:39::i;28815:222::-;28875:7;;;28919:15;:7;28931:2;28919:11;:15::i;:::-;28904:30;-1:-1:-1;28945:23:0;28971:17;:7;28904:30;28971:11;:17::i;:::-;28945:43;-1:-1:-1;29024:4:0;;-1:-1:-1;;28815:222:0;;;:::o;29045:334::-;29140:7;;;;29196:24;:7;29208:11;29196;:24::i;:::-;29178:42;-1:-1:-1;29231:12:0;29246:21;:4;29255:11;29246:8;:21::i;:::-;29231:36;-1:-1:-1;29278:23:0;29304:17;:7;29231:36;29304:11;:17::i;:::-;29340:7;;;;-1:-1:-1;29366:4:0;;-1:-1:-1;29045:334:0;;-1:-1:-1;;;;;29045:334:0:o;28383:225::-;28446:7;;;28491:15;:6;28502:3;28491:10;:15::i;25721:509::-;25824:15;25841:23;25866:12;25880:23;25905:12;25921:19;25932:7;25921:10;:19::i;:::-;-1:-1:-1;;;;;25969:15:0;;;;;;:7;:15;;;;;;25823:117;;-1:-1:-1;25823:117:0;;-1:-1:-1;25823:117:0;;-1:-1:-1;25823:117:0;-1:-1:-1;25823:117:0;-1:-1:-1;25969:28:0;;25989:7;25969:19;:28::i;:::-;-1:-1:-1;;;;;25951:15:0;;;;;;:7;:15;;;;;;;;:46;;;;26026:7;:15;;;;:28;;26046:7;26026:19;:28::i;:::-;-1:-1:-1;;;;;26008:15:0;;;;;;;:7;:15;;;;;;:46;;;;26086:18;;;;;;;:39;;26109:15;26086:22;:39::i;:::-;-1:-1:-1;;;;;26065:18:0;;;;;;:7;:18;;;;;:60;26139:23;26151:4;26157;26139:11;:23::i;:::-;26195:9;-1:-1:-1;;;;;26178:44:0;26187:6;-1:-1:-1;;;;;26178:44:0;;26206:15;26178:44;;;;;;;;;;;;;;;;;;25721:509;;;;;;;;:::o;27235:200::-;27342:49;27364:6;27372:9;27383:7;27342:21;:49::i;:::-;27402:25;27419:7;27402:16;:25::i;:::-;27235:200;;;:::o;25184:529::-;25285:15;25302:23;25327:12;25341:23;25366:12;25382:19;25393:7;25382:10;:19::i;:::-;-1:-1:-1;;;;;25430:15:0;;;;;;:7;:15;;;;;;25284:117;;-1:-1:-1;25284:117:0;;-1:-1:-1;25284:117:0;;-1:-1:-1;25284:117:0;-1:-1:-1;25284:117:0;-1:-1:-1;25430:28:0;;25284:117;25430:19;:28::i;:::-;-1:-1:-1;;;;;25412:15:0;;;;;;;:7;:15;;;;;;;;:46;;;;25490:18;;;;;:7;:18;;;;;:39;;25513:15;25490:22;:39::i;:::-;-1:-1:-1;;;;;25469:18:0;;;;;;:7;:18;;;;;;;;:60;;;;25561:7;:18;;;;:39;;25584:15;25561:22;:39::i;27031:196::-;27136:47;27156:6;27164:9;27175:7;27136:19;:47::i;24716:460::-;24815:15;24832:23;24857:12;24871:23;24896:12;24912:19;24923:7;24912:10;:19::i;:::-;-1:-1:-1;;;;;24960:15:0;;;;;;:7;:15;;;;;;24814:117;;-1:-1:-1;24814:117:0;;-1:-1:-1;24814:117:0;;-1:-1:-1;24814:117:0;-1:-1:-1;24814:117:0;-1:-1:-1;24960:28:0;;24814:117;24960:19;:28::i;26831:192::-;26934:45;26952:6;26960:9;26971:7;26934:17;:45::i;26238:585::-;26341:15;26358:23;26383:12;26397:23;26422:12;26438:19;26449:7;26438:10;:19::i;:::-;-1:-1:-1;;;;;26486:15:0;;;;;;:7;:15;;;;;;26340:117;;-1:-1:-1;26340:117:0;;-1:-1:-1;26340:117:0;;-1:-1:-1;26340:117:0;-1:-1:-1;26340:117:0;-1:-1:-1;26486:28:0;;26506:7;26486:19;:28::i;:::-;-1:-1:-1;;;;;26468:15:0;;;;;;:7;:15;;;;;;;;:46;;;;26543:7;:15;;;;:28;;26563:7;26543:19;:28::i;27443:200::-;27550:49;27572:6;27580:9;27591:7;27550:21;:49::i;29558:561::-;29655:7;;29608;;;;18123:17;29608:7;29715:289;29739:9;:16;29735:20;;29715:289;;;29805:7;29781;:21;29789:9;29799:1;29789:12;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29789:12:0;29781:21;;;;;;;;;;;;;:31;;:66;;;29840:7;29816;:21;29824:9;29834:1;29824:12;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29824:12:0;29816:21;;;;;;;;;;;;;:31;29781:66;29777:97;;;29857:7;;18123:17;29849:25;;;;;;;;;29777:97;29899:34;29911:7;:21;29919:9;29929:1;29919:12;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29919:12:0;29911:21;;;;;;;;;;;;;29899:7;;:11;:34::i;:::-;29889:44;;29958:34;29970:7;:21;29978:9;29988:1;29978:12;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29978:12:0;29970:21;;;;;;;;;;;;;29958:7;;:11;:34::i;:::-;29948:44;-1:-1:-1;29757:3:0;;29715:289;;;-1:-1:-1;30028:7:0;;:20;;18123:17;30028:11;:20::i;:::-;30018:7;:30;30014:61;;;30058:7;;18123:17;30050:25;;;;;;;;30014:61;30094:7;;-1:-1:-1;30103:7:0;-1:-1:-1;29558:561:0;;;:::o;15938:278::-;16024:7;16059:12;16052:5;16044:28;;;;-1:-1:-1;;;16044:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16083:9;16099:1;16095;:5;;;;;;;15938:278;-1:-1:-1;;;;;15938:278:0:o;14363:471::-;14421:7;14666:6;14662:47;;-1:-1:-1;14696:1:0;14689:8;;14662:47;14733:5;;;14737:1;14733;:5;:1;14757:5;;;;;:10;14749:56;;;;-1:-1:-1;;;14749:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27809:147;27887:7;;:17;;27899:4;27887:11;:17::i;:::-;27877:7;:27;27928:10;;:20;;27943:4;27928:14;:20::i;:::-;27915:10;:33;-1:-1:-1;;27809:147:0:o;27651:150::-;27709:12;27724:17;27737:3;27724:12;:17::i;:::-;27769:14;;27709:32;;-1:-1:-1;27769:24:0;;27709:32;27769:18;:24::i;:::-;27752:14;:41;-1:-1:-1;;27651:150:0:o;28616:191::-;28676:7;;28711:14;:6;28722:2;28711:10;:14::i;:::-;28696:29;-1:-1:-1;28736:16:0;28755;:6;28696:29;28755:10;:16::i;:::-;28736:35;28616:191;-1:-1:-1;;;;28616:191:0:o
Swarm Source
ipfs://e9577b24681e35973f05261520756c8be1b5d8d97720ca7225e3d9326d66886f
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.