Token

ERC-20: Blur Inu (BLRINU)

ERC-20

Overview

Max Total Supply

1,000,000,000 BLRINU

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 9 Decimals)

0xedea0b4552e4463ac553ac0c702a5016a98ba649

Filtered by Token Holder

0xD1E8fd37E062B2337Dac47e823115d3810F9F55a

Balance

1,920,124.569245194 BLRINU

Value

$0.00

0xd1e8fd37e062b2337dac47e823115d3810f9f55a

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x0BF23DA5...7a3A6a0c0
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:

BuybackBabyToken

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-09-20
*/

// Dependency file: @openzeppelin/contracts/utils/math/SafeMath.sol

// SPDX-License-Identifier: MIT

// pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

    /**
     * @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 a - b;
    }

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// Dependency file: @openzeppelin/contracts/proxy/Clones.sol


// pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create(0, ptr, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create2(0, ptr, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
            mstore(add(ptr, 0x38), shl(0x60, deployer))
            mstore(add(ptr, 0x4c), salt)
            mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
            predicted := keccak256(add(ptr, 0x37), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(address implementation, bytes32 salt)
        internal
        view
        returns (address predicted)
    {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}


// Dependency file: @openzeppelin/contracts/utils/Address.sol


// pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @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");

        (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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// Dependency file: contracts/interfaces/IUniswapV2Factory.sol

// pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}


// Dependency file: contracts/interfaces/IUniswapV2Router02.sol

// pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}


// Dependency file: contracts/interfaces/IERC20Extended.sol

// pragma solidity =0.8.4;

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

    function decimals() external view returns (uint8);

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

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

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


// Dependency file: contracts/buyback/Auth.sol

// pragma solidity =0.8.4;

abstract contract Auth {
    address internal owner;
    mapping(address => bool) internal authorizations;

    constructor(address _owner) {
        owner = _owner;
        authorizations[_owner] = true;
    }

    /**
     * Function modifier to require caller to be contract owner
     */
    modifier onlyOwner() {
        require(isOwner(msg.sender), "!OWNER");
        _;
    }

    /**
     * Function modifier to require caller to be authorized
     */
    modifier authorized() {
        require(isAuthorized(msg.sender), "!AUTHORIZED");
        _;
    }

    /**
     * Authorize address. Owner only
     */
    function authorize(address adr) public onlyOwner {
        authorizations[adr] = true;
    }

    /**
     * Remove address' authorization. Owner only
     */
    function unauthorize(address adr) public onlyOwner {
        authorizations[adr] = false;
    }

    /**
     * Check if address is owner
     */
    function isOwner(address account) public view returns (bool) {
        return account == owner;
    }

    /**
     * Return address' authorization status
     */
    function isAuthorized(address adr) public view returns (bool) {
        return authorizations[adr];
    }

    /**
     * Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
     */
    function transferOwnership(address payable adr) public onlyOwner {
        owner = adr;
        authorizations[adr] = true;
        emit OwnershipTransferred(adr);
    }

    event OwnershipTransferred(address owner);
}


// Dependency file: contracts/buyback/DividendDistributor.sol

// pragma solidity =0.8.4;

// import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// import "contracts/interfaces/IUniswapV2Router02.sol";
// import "contracts/interfaces/IERC20Extended.sol";

interface IDividendDistributor {
    function setDistributionCriteria(
        uint256 _minPeriod,
        uint256 _minDistribution
    ) external;

    function setShare(address shareholder, uint256 amount) external;

    function deposit() external payable;

    function process(uint256 gas) external;
}

contract DividendDistributor is IDividendDistributor {
    using SafeMath for uint256;

    address public _token;

    struct Share {
        uint256 amount;
        uint256 totalExcluded;
        uint256 totalRealised;
    }

    IERC20Extended public rewardToken;
    IUniswapV2Router02 public router;

    address[] public shareholders;
    mapping(address => uint256) public shareholderIndexes;
    mapping(address => uint256) public shareholderClaims;

    mapping(address => Share) public shares;

    uint256 public totalShares;
    uint256 public totalDividends;
    uint256 public totalDistributed;
    uint256 public dividendsPerShare;
    uint256 public dividendsPerShareAccuracyFactor;

    uint256 public minPeriod;
    uint256 public minDistribution;

    uint256 currentIndex;

    bool initialized;
    modifier initializer() {
        require(!initialized);
        _;
        initialized = true;
    }

    modifier onlyToken() {
        require(msg.sender == _token);
        _;
    }

    constructor(address rewardToken_, address router_) {
        _token = msg.sender;
        rewardToken = IERC20Extended(rewardToken_);
        router = IUniswapV2Router02(router_);

        dividendsPerShareAccuracyFactor = 10**36;
        minPeriod = 1 hours;
        minDistribution = 1 * (10**rewardToken.decimals());
    }

    function setDistributionCriteria(
        uint256 _minPeriod,
        uint256 _minDistribution
    ) external override onlyToken {
        minPeriod = _minPeriod;
        minDistribution = _minDistribution;
    }

    function setShare(address shareholder, uint256 amount)
        external
        override
        onlyToken
    {
        if (shares[shareholder].amount > 0) {
            distributeDividend(shareholder);
        }

        if (amount > 0 && shares[shareholder].amount == 0) {
            addShareholder(shareholder);
        } else if (amount == 0 && shares[shareholder].amount > 0) {
            removeShareholder(shareholder);
        }

        totalShares = totalShares.sub(shares[shareholder].amount).add(amount);
        shares[shareholder].amount = amount;
        shares[shareholder].totalExcluded = getCumulativeDividends(
            shares[shareholder].amount
        );
    }

    function deposit() external payable override onlyToken {
        uint256 balanceBefore = rewardToken.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = router.WETH();
        path[1] = address(rewardToken);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{
            value: msg.value
        }(0, path, address(this), block.timestamp);

        uint256 amount = rewardToken.balanceOf(address(this)).sub(
            balanceBefore
        );

        totalDividends = totalDividends.add(amount);
        dividendsPerShare = dividendsPerShare.add(
            dividendsPerShareAccuracyFactor.mul(amount).div(totalShares)
        );
    }

    function process(uint256 gas) external override onlyToken {
        uint256 shareholderCount = shareholders.length;

        if (shareholderCount == 0) {
            return;
        }

        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();

        uint256 iterations = 0;

        while (gasUsed < gas && iterations < shareholderCount) {
            if (currentIndex >= shareholderCount) {
                currentIndex = 0;
            }

            if (shouldDistribute(shareholders[currentIndex])) {
                distributeDividend(shareholders[currentIndex]);
            }

            gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
            gasLeft = gasleft();
            currentIndex++;
            iterations++;
        }
    }

    function shouldDistribute(address shareholder)
        internal
        view
        returns (bool)
    {
        return
            shareholderClaims[shareholder] + minPeriod < block.timestamp &&
            getUnpaidEarnings(shareholder) > minDistribution;
    }

    function distributeDividend(address shareholder) internal {
        if (shares[shareholder].amount == 0) {
            return;
        }

        uint256 amount = getUnpaidEarnings(shareholder);
        if (amount > 0) {
            totalDistributed = totalDistributed.add(amount);
            rewardToken.transfer(shareholder, amount);
            shareholderClaims[shareholder] = block.timestamp;
            shares[shareholder].totalRealised = shares[shareholder]
                .totalRealised
                .add(amount);
            shares[shareholder].totalExcluded = getCumulativeDividends(
                shares[shareholder].amount
            );
        }
    }

    function claimDividend() external {
        distributeDividend(msg.sender);
    }

    function getUnpaidEarnings(address shareholder)
        public
        view
        returns (uint256)
    {
        if (shares[shareholder].amount == 0) {
            return 0;
        }

        uint256 shareholderTotalDividends = getCumulativeDividends(
            shares[shareholder].amount
        );
        uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded;

        if (shareholderTotalDividends <= shareholderTotalExcluded) {
            return 0;
        }

        return shareholderTotalDividends.sub(shareholderTotalExcluded);
    }

    function getCumulativeDividends(uint256 share)
        internal
        view
        returns (uint256)
    {
        return
            share.mul(dividendsPerShare).div(dividendsPerShareAccuracyFactor);
    }

    function addShareholder(address shareholder) internal {
        shareholderIndexes[shareholder] = shareholders.length;
        shareholders.push(shareholder);
    }

    function removeShareholder(address shareholder) internal {
        shareholders[shareholderIndexes[shareholder]] = shareholders[
            shareholders.length - 1
        ];
        shareholderIndexes[
            shareholders[shareholders.length - 1]
        ] = shareholderIndexes[shareholder];
        shareholders.pop();
    }
}


// Dependency file: contracts/BaseToken.sol

// pragma solidity =0.8.4;

enum TokenType {
    standard,
    antiBotStandard,
    liquidityGenerator,
    antiBotLiquidityGenerator,
    baby,
    antiBotBaby,
    buybackBaby,
    antiBotBuybackBaby
}

abstract contract BaseToken {
    event TokenCreated(
        address indexed owner,
        address indexed token,
        TokenType tokenType,
        uint256 version
    );
}


// Root file: contracts/buyback/BuybackBabyToken.sol

pragma solidity =0.8.4;

// import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// import "@openzeppelin/contracts/proxy/Clones.sol";
// import "@openzeppelin/contracts/utils/Address.sol";

// import "contracts/interfaces/IUniswapV2Factory.sol";
// import "contracts/interfaces/IUniswapV2Router02.sol";
// import "contracts/interfaces/IERC20Extended.sol";
// import "contracts/buyback/Auth.sol";
// import "contracts/buyback/DividendDistributor.sol";
// import "contracts/BaseToken.sol";

contract BuybackBabyToken is IERC20Extended, Auth, BaseToken {
    using SafeMath for uint256;
    using Address for address;
    using Address for address payable;

    uint256 public constant VERSION = 2;

    address private constant DEAD = address(0xdead);
    address private constant ZERO = address(0);
    uint8 private constant _decimals = 9;

    string private _name;
    string private _symbol;
    uint256 private _totalSupply;

    address public rewardToken;
    IUniswapV2Router02 public router;
    address public pair;
    address public marketingFeeReceiver;

    uint256 public liquidityFee; // default: 200
    uint256 public buybackFee; // default: 300
    uint256 public reflectionFee; // default: 800
    uint256 public marketingFee; // default: 100
    uint256 public totalFee;
    uint256 public feeDenominator; // default: 10000

    uint256 public targetLiquidity; // default: 25
    uint256 public targetLiquidityDenominator; // default: 100

    uint256 public buybackMultiplierNumerator; // default: 200
    uint256 public buybackMultiplierDenominator; // default: 100
    uint256 public buybackMultiplierTriggeredAt;
    uint256 public buybackMultiplierLength; // default: 30 mins

    bool public autoBuybackEnabled;

    uint256 public autoBuybackCap;
    uint256 public autoBuybackAccumulator;
    uint256 public autoBuybackAmount;
    uint256 public autoBuybackBlockPeriod;
    uint256 public autoBuybackBlockLast;

    DividendDistributor public distributor;

    uint256 public distributorGas;

    bool public swapEnabled;
    uint256 public swapThreshold;

    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    mapping(address => bool) public buyBacker;
    mapping(address => bool) public isFeeExempt;
    mapping(address => bool) public isDividendExempt;

    event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
    event BuybackMultiplierActive(uint256 duration);

    bool inSwap;
    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

    modifier onlyBuybacker() {
        require(buyBacker[msg.sender] == true, "Not a buybacker");
        _;
    }

    constructor(
        string memory name_,
        string memory symbol_,
        uint256 totalSupply_,
        address rewardToken_,
        address router_,
        uint256[5] memory feeSettings_,
        address serviceFeeReceiver_,
        uint256 serviceFee_
    ) payable Auth(msg.sender) {
        _name = name_;
        _symbol = symbol_;
        _totalSupply = totalSupply_;

        rewardToken = rewardToken_;
        router = IUniswapV2Router02(router_);
        pair = IUniswapV2Factory(router.factory()).createPair(
            address(this),
            router.WETH()
        );
        distributor = new DividendDistributor(rewardToken_, router_);

        _initializeFees(feeSettings_);
        _initializeLiquidityBuyBack();

        distributorGas = 500_000;
        swapEnabled = true;
        swapThreshold = _totalSupply / 1000; // 0.1%

        isFeeExempt[msg.sender] = true;
        isDividendExempt[pair] = true;
        isDividendExempt[address(this)] = true;
        isDividendExempt[DEAD] = true;
        buyBacker[msg.sender] = true;

        marketingFeeReceiver = msg.sender;
        require(
            !marketingFeeReceiver.isContract(),
            "Marketing wallet cannot be a contract"
        );

        _allowances[address(this)][address(router)] = _totalSupply;
        _allowances[address(this)][address(pair)] = _totalSupply;

        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);

        emit TokenCreated(
            msg.sender,
            address(this),
            TokenType.buybackBaby,
            VERSION
        );

        payable(serviceFeeReceiver_).transfer(serviceFee_);
    }

    function _initializeFees(uint256[5] memory feeSettings_) internal {
        _setFees(
            feeSettings_[0], // liquidityFee
            feeSettings_[1], // buybackFee
            feeSettings_[2], // reflectionFee
            feeSettings_[3], // marketingFee
            feeSettings_[4] // feeDenominator
        );
    }

    function _initializeLiquidityBuyBack() internal {
        targetLiquidity = 25;
        targetLiquidityDenominator = 100;

        buybackMultiplierNumerator = 200;
        buybackMultiplierDenominator = 100;
        buybackMultiplierLength = 30 minutes;
    }

    receive() external payable {}

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

    function decimals() external pure override returns (uint8) {
        return _decimals;
    }

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

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

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

    function allowance(address holder, address spender)
        external
        view
        override
        returns (uint256)
    {
        return _allowances[holder][spender];
    }

    function approve(address spender, uint256 amount)
        public
        override
        returns (bool)
    {
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function approveMax(address spender) external returns (bool) {
        return approve(spender, _totalSupply);
    }

    function transfer(address recipient, uint256 amount)
        external
        override
        returns (bool)
    {
        return _transferFrom(msg.sender, recipient, amount);
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external override returns (bool) {
        if (_allowances[sender][msg.sender] != _totalSupply) {
            _allowances[sender][msg.sender] = _allowances[sender][msg.sender]
                .sub(amount, "Insufficient Allowance");
        }

        return _transferFrom(sender, recipient, amount);
    }

    function _transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        if (inSwap) {
            return _basicTransfer(sender, recipient, amount);
        }

        if (shouldSwapBack()) {
            swapBack();
        }
        if (shouldAutoBuyback()) {
            triggerAutoBuyback();
        }

        _balances[sender] = _balances[sender].sub(
            amount,
            "Insufficient Balance"
        );

        uint256 amountReceived = shouldTakeFee(sender)
            ? takeFee(sender, recipient, amount)
            : amount;

        _balances[recipient] = _balances[recipient].add(amountReceived);

        if (!isDividendExempt[sender]) {
            try distributor.setShare(sender, _balances[sender]) {} catch {}
        }
        if (!isDividendExempt[recipient]) {
            try
                distributor.setShare(recipient, _balances[recipient])
            {} catch {}
        }

        try distributor.process(distributorGas) {} catch {}

        emit Transfer(sender, recipient, amountReceived);
        return true;
    }

    function _basicTransfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        _balances[sender] = _balances[sender].sub(
            amount,
            "Insufficient Balance"
        );
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function shouldTakeFee(address sender) internal view returns (bool) {
        return !isFeeExempt[sender] && totalFee > 0;
    }

    function getTotalFee(bool selling) public view returns (uint256) {
        if (selling) {
            return getMultipliedFee();
        }
        return totalFee;
    }

    function getMultipliedFee() public view returns (uint256) {
        if (
            buybackMultiplierTriggeredAt.add(buybackMultiplierLength) >
            block.timestamp
        ) {
            uint256 remainingTime = buybackMultiplierTriggeredAt
                .add(buybackMultiplierLength)
                .sub(block.timestamp);
            uint256 feeIncrease = totalFee
                .mul(buybackMultiplierNumerator)
                .div(buybackMultiplierDenominator)
                .sub(totalFee);

            uint256 increasedFee = totalFee.add(
                feeIncrease.mul(remainingTime).div(buybackMultiplierLength)
            );
            return
                increasedFee > feeDenominator / 4
                    ? feeDenominator / 4
                    : increasedFee;
        }
        return totalFee;
    }

    function takeFee(
        address sender,
        address receiver,
        uint256 amount
    ) internal returns (uint256) {
        uint256 feeAmount = amount.mul(getTotalFee(receiver == pair)).div(
            feeDenominator
        );

        _balances[address(this)] = _balances[address(this)].add(feeAmount);
        emit Transfer(sender, address(this), feeAmount);

        return amount.sub(feeAmount);
    }

    function shouldSwapBack() internal view returns (bool) {
        return
            msg.sender != pair &&
            !inSwap &&
            swapEnabled &&
            _balances[address(this)] >= swapThreshold;
    }

    function swapBack() internal swapping {
        uint256 dynamicLiquidityFee = isOverLiquified(
            targetLiquidity,
            targetLiquidityDenominator
        )
            ? 0
            : liquidityFee;
        uint256 amountToLiquify;
        if (totalFee > 0) {
            amountToLiquify = swapThreshold
                .mul(dynamicLiquidityFee)
                .div(totalFee)
                .div(2);
        }
        uint256 amountToSwap = swapThreshold.sub(amountToLiquify);

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();
        uint256 balanceBefore = address(this).balance;

        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amountBNB = address(this).balance.sub(balanceBefore);

        uint256 totalBNBFee = totalFee.sub(dynamicLiquidityFee.div(2));

        uint256 amountBNBLiquidity;
        if (totalBNBFee > 0) {
            amountBNBLiquidity = amountBNB
                .mul(dynamicLiquidityFee)
                .div(totalBNBFee)
                .div(2);

            uint256 amountBNBReflection = amountBNB.mul(reflectionFee).div(
                totalBNBFee
            );
            uint256 amountBNBMarketing = amountBNB.mul(marketingFee).div(
                totalBNBFee
            );

            try distributor.deposit{value: amountBNBReflection}() {} catch {}
            payable(marketingFeeReceiver).transfer(amountBNBMarketing);
        }

        if (amountToLiquify > 0) {
            router.addLiquidityETH{value: amountBNBLiquidity}(
                address(this),
                amountToLiquify,
                0,
                0,
                DEAD,
                block.timestamp
            );
            emit AutoLiquify(amountBNBLiquidity, amountToLiquify);
        }
    }

    function shouldAutoBuyback() internal view returns (bool) {
        return
            msg.sender != pair &&
            !inSwap &&
            autoBuybackEnabled &&
            autoBuybackBlockLast + autoBuybackBlockPeriod <= block.number && // After N blocks from last buyback
            address(this).balance >= autoBuybackAmount;
    }

    function triggerZeusBuyback(uint256 amount, bool triggerBuybackMultiplier)
        external
        authorized
    {
        buyTokens(amount, DEAD);
        if (triggerBuybackMultiplier) {
            buybackMultiplierTriggeredAt = block.timestamp;
            emit BuybackMultiplierActive(buybackMultiplierLength);
        }
    }

    function clearBuybackMultiplier() external authorized {
        buybackMultiplierTriggeredAt = 0;
    }

    function triggerAutoBuyback() internal {
        buyTokens(autoBuybackAmount, DEAD);
        autoBuybackBlockLast = block.number;
        autoBuybackAccumulator = autoBuybackAccumulator.add(autoBuybackAmount);
        if (autoBuybackAccumulator > autoBuybackCap) {
            autoBuybackEnabled = false;
        }
    }

    function buyTokens(uint256 amount, address to) internal swapping {
        address[] memory path = new address[](2);
        path[0] = router.WETH();
        path[1] = address(this);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{
            value: amount
        }(0, path, to, block.timestamp);
    }

    function setAutoBuybackSettings(
        bool _enabled,
        uint256 _cap,
        uint256 _amount,
        uint256 _period
    ) external authorized {
        require(_period > 0, "Period must be greater than 0");
        autoBuybackEnabled = _enabled;
        autoBuybackCap = _cap;
        autoBuybackAccumulator = 0;
        autoBuybackAmount = _amount;
        autoBuybackBlockPeriod = _period;
        autoBuybackBlockLast = block.number;
    }

    function setBuybackMultiplierSettings(
        uint256 numerator,
        uint256 denominator,
        uint256 length
    ) external authorized {
        require(length <= 2 hours, "Length must be less than 2 hours");
        require(numerator / denominator <= 2 && numerator > denominator);
        buybackMultiplierNumerator = numerator;
        buybackMultiplierDenominator = denominator;
        buybackMultiplierLength = length;
    }

    function setIsDividendExempt(address holder, bool exempt)
        external
        authorized
    {
        require(holder != address(this) && holder != pair);
        isDividendExempt[holder] = exempt;
        if (exempt) {
            distributor.setShare(holder, 0);
        } else {
            distributor.setShare(holder, _balances[holder]);
        }
    }

    function setIsFeeExempt(address holder) external authorized {
        isFeeExempt[holder] = true;
    }

    function setBuyBacker(address acc, bool add) external authorized {
        buyBacker[acc] = add;
    }

    function setFees(
        uint256 _liquidityFee,
        uint256 _buybackFee,
        uint256 _reflectionFee,
        uint256 _marketingFee,
        uint256 _feeDenominator
    ) public authorized {
        _setFees(
            _liquidityFee,
            _buybackFee,
            _reflectionFee,
            _marketingFee,
            _feeDenominator
        );
    }

    function _setFees(
        uint256 _liquidityFee,
        uint256 _buybackFee,
        uint256 _reflectionFee,
        uint256 _marketingFee,
        uint256 _feeDenominator
    ) internal {
        liquidityFee = _liquidityFee;
        buybackFee = _buybackFee;
        reflectionFee = _reflectionFee;
        marketingFee = _marketingFee;
        totalFee = _liquidityFee.add(_buybackFee).add(_reflectionFee).add(
            _marketingFee
        );
        feeDenominator = _feeDenominator;
        require(
            totalFee <= feeDenominator / 4,
            "Total fee should not be greater than 1/4 of fee denominator"
        );
    }

    function setFeeReceivers(address _marketingFeeReceiver)
        external
        authorized
    {
        require(
            _marketingFeeReceiver != marketingFeeReceiver,
            "Marketing wallet is already that address"
        );
        require(
            !_marketingFeeReceiver.isContract(),
            "Marketing wallet cannot be a contract"
        );
        marketingFeeReceiver = _marketingFeeReceiver;
    }

    function setSwapBackSettings(bool _enabled, uint256 _amount)
        external
        authorized
    {
        require(
            _enabled && _amount >= _totalSupply / 100_000,
            "Swapback amount should be at least 0.001% of total supply"
        );
        swapEnabled = _enabled;
        swapThreshold = _amount;
    }

    function setTargetLiquidity(uint256 _target, uint256 _denominator)
        external
        authorized
    {
        require(_denominator > 0, "Denominator must be greater than 0");
        targetLiquidity = _target;
        targetLiquidityDenominator = _denominator;
    }

    function setDistributionCriteria(
        uint256 _minPeriod,
        uint256 _minDistribution
    ) external onlyOwner {
        distributor.setDistributionCriteria(_minPeriod, _minDistribution);
    }

    function setDistributorSettings(uint256 gas) external authorized {
        require(
            gas >= 200_000 && gas <= 500_000,
            "gasForProcessing must be between 200,000 and 500,000"
        );
        distributorGas = gas;
    }

    function getCirculatingSupply() public view returns (uint256) {
        return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
    }

    function getLiquidityBacking(uint256 accuracy)
        public
        view
        returns (uint256)
    {
        return accuracy.mul(balanceOf(pair).mul(2)).div(getCirculatingSupply());
    }

    function isOverLiquified(uint256 target, uint256 accuracy)
        public
        view
        returns (bool)
    {
        return getLiquidityBacking(accuracy) > target;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint256","name":"totalSupply_","type":"uint256"},{"internalType":"address","name":"rewardToken_","type":"address"},{"internalType":"address","name":"router_","type":"address"},{"internalType":"uint256[5]","name":"feeSettings_","type":"uint256[5]"},{"internalType":"address","name":"serviceFeeReceiver_","type":"address"},{"internalType":"uint256","name":"serviceFee_","type":"uint256"}],"stateMutability":"payable","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":false,"internalType":"uint256","name":"amountBNB","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountBOG","type":"uint256"}],"name":"AutoLiquify","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"duration","type":"uint256"}],"name":"BuybackMultiplierActive","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"enum TokenType","name":"tokenType","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"version","type":"uint256"}],"name":"TokenCreated","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":[],"name":"VERSION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"holder","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":"spender","type":"address"}],"name":"approveMax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"authorize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"autoBuybackAccumulator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoBuybackAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoBuybackBlockLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoBuybackBlockPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoBuybackCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoBuybackEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"buyBacker","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buybackFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buybackMultiplierDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buybackMultiplierLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buybackMultiplierNumerator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buybackMultiplierTriggeredAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clearBuybackMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"distributor","outputs":[{"internalType":"contract DividendDistributor","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributorGas","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"accuracy","type":"uint256"}],"name":"getLiquidityBacking","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMultipliedFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"selling","type":"bool"}],"name":"getTotalFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"isAuthorized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isDividendExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"target","type":"uint256"},{"internalType":"uint256","name":"accuracy","type":"uint256"}],"name":"isOverLiquified","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"reflectionFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"},{"internalType":"uint256","name":"_cap","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_period","type":"uint256"}],"name":"setAutoBuybackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"acc","type":"address"},{"internalType":"bool","name":"add","type":"bool"}],"name":"setBuyBacker","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"numerator","type":"uint256"},{"internalType":"uint256","name":"denominator","type":"uint256"},{"internalType":"uint256","name":"length","type":"uint256"}],"name":"setBuybackMultiplierSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minPeriod","type":"uint256"},{"internalType":"uint256","name":"_minDistribution","type":"uint256"}],"name":"setDistributionCriteria","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"gas","type":"uint256"}],"name":"setDistributorSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_marketingFeeReceiver","type":"address"}],"name":"setFeeReceivers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_buybackFee","type":"uint256"},{"internalType":"uint256","name":"_reflectionFee","type":"uint256"},{"internalType":"uint256","name":"_marketingFee","type":"uint256"},{"internalType":"uint256","name":"_feeDenominator","type":"uint256"}],"name":"setFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsDividendExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"}],"name":"setIsFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setSwapBackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_target","type":"uint256"},{"internalType":"uint256","name":"_denominator","type":"uint256"}],"name":"setTargetLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"targetLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"targetLiquidityDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","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 payable","name":"adr","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"triggerBuybackMultiplier","type":"bool"}],"name":"triggerZeusBuyback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"unauthorize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

36011:18111:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37624:28;;;;;;;;;;;;;;;;;;;13099:25:1;;;13087:2;13072:18;37624:28:0;;;;;;;;49420:466;;;;;;;;;;-1:-1:-1;49420:466:0;;;;;:::i;:::-;;:::i;:::-;;50958:382;;;;;;;;;;-1:-1:-1;50958:382:0;;;;;:::i;:::-;;:::i;41023:94::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;41448:248::-;;;;;;;;;;-1:-1:-1;41448:248:0;;;;;:::i;:::-;;:::i;:::-;;;7446:14:1;;7439:22;7421:41;;7409:2;7394:18;41448:248:0;7376:92:1;37196:38:0;;;;;;;;;;;;;;;;53937:182;;;;;;;;;;-1:-1:-1;53937:182:0;;;;;:::i;:::-;;:::i;50846:104::-;;;;;;;;;;-1:-1:-1;50846:104:0;;;;;:::i;:::-;;:::i;36842:29::-;;;;;;;;;;;;;;;;40705:102;;;;;;;;;;-1:-1:-1;40787:12:0;;40705:102;;37146:43;;;;;;;;;;;;;;;;36812:23;;;;;;;;;;;;;;;;52820:280;;;;;;;;;;-1:-1:-1;52820:280:0;;;;;:::i;:::-;;:::i;49894:449::-;;;;;;;;;;-1:-1:-1;49894:449:0;;;;;:::i;:::-;;:::i;42025:419::-;;;;;;;;;;-1:-1:-1;42025:419:0;;;;;:::i;:::-;;:::i;53580:142::-;;;;;;;;;;;;;:::i;53108:207::-;;;;;;;;;;-1:-1:-1;53108:207:0;;;;;:::i;:::-;;:::i;27511:103::-;;;;;;;;;;-1:-1:-1;27511:103:0;;;;;:::i;:::-;27566:4;27601:5;-1:-1:-1;;;;;27590:16:0;;;27601:5;;27590:16;;27511:103;40815:94;;;;;;;;;;-1:-1:-1;40815:94:0;;36368:1;14117:36:1;;14105:2;14090:18;40815:94:0;14072:87:1;36663:25:0;;;;;;;;;;;;;;;;37263:30;;;;;;;;;;-1:-1:-1;37263:30:0;;;;;;;;37837:43;;;;;;;;;;-1:-1:-1;37837:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;37887:48;;;;;;;;;;-1:-1:-1;37887:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;37382:32;;;;;;;;;;;;;;;;41704:117;;;;;;;;;;-1:-1:-1;41704:117:0;;;;;:::i;:::-;;:::i;37302:29::-;;;;;;;;;;;;;;;;37421:37;;;;;;;;;;;;;;;;37556:29;;;;;;;;;;;;;;;;36762:27;;;;;;;;;;;;;;;;37594:23;;;;;;;;;;-1:-1:-1;37594:23:0;;;;;;;;37338:37;;;;;;;;;;;;;;;;41125:119;;;;;;;;;;-1:-1:-1;41125:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;41218:18:0;41191:7;41218:18;;;:9;:18;;;;;;;41125:119;36711:28;;;;;;;;;;;;;;;;50733:105;;;;;;;;;;-1:-1:-1;50733:105:0;;;;;:::i;:::-;;:::i;36950:41::-;;;;;;;;;;;;;;;;37016;;;;;;;;;;;;;;;;36898:30;;;;;;;;;;;;;;;;40917:98;;;;;;;;;;;;;:::i;36613:27::-;;;;;;;;;;;;;;;;53323:249;;;;;;;;;;-1:-1:-1;53323:249:0;;;;;:::i;:::-;;:::i;36543:19::-;;;;;;;;;;-1:-1:-1;36543:19:0;;;;-1:-1:-1;;;;;36543:19:0;;;;;;-1:-1:-1;;;;;5843:32:1;;;5825:51;;5813:2;5798:18;36543:19:0;5780:102:1;41829:188:0;;;;;;;;;;-1:-1:-1;41829:188:0;;;;;:::i;:::-;;:::i;48633:105::-;;;;;;;;;;;;;:::i;27184:94::-;;;;;;;;;;-1:-1:-1;27184:94:0;;;;;:::i;:::-;;:::i;37465:35::-;;;;;;;;;;;;;;;;37509:38;;;;;;;;;;-1:-1:-1;37509:38:0;;;;-1:-1:-1;;;;;37509:38:0;;;53730:199;;;;;;;;;;-1:-1:-1;53730:199:0;;;;;:::i;:::-;;:::i;44356:859::-;;;;;;;;;;;;;:::i;41252:188::-;;;;;;;;;;-1:-1:-1;41252:188:0;;;;;:::i;:::-;-1:-1:-1;;;;;41404:19:0;;;41372:7;41404:19;;;:11;:19;;;;;;;:28;;;;;;;;;;;;;41252:188;52470:342;;;;;;;;;;-1:-1:-1;52470:342:0;;;;;:::i;:::-;;:::i;52021:441::-;;;;;;;;;;-1:-1:-1;52021:441:0;;;;;:::i;:::-;;:::i;36569:35::-;;;;;;;;;;-1:-1:-1;36569:35:0;;;;-1:-1:-1;;;;;36569:35:0;;;37080:43;;;;;;;;;;;;;;;;37789:41;;;;;;;;;;-1:-1:-1;37789:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;27354:97;;;;;;;;;;-1:-1:-1;27354:97:0;;;;;:::i;:::-;;:::i;44174:174::-;;;;;;;;;;-1:-1:-1;44174:174:0;;;;;:::i;:::-;;:::i;27911:173::-;;;;;;;;;;-1:-1:-1;27911:173:0;;;;;:::i;:::-;;:::i;48284:341::-;;;;;;;;;;-1:-1:-1;48284:341:0;;;;;:::i;:::-;;:::i;50351:374::-;;;;;;;;;;-1:-1:-1;50351:374:0;;;;;:::i;:::-;;:::i;36471:26::-;;;;;;;;;;-1:-1:-1;36471:26:0;;;;-1:-1:-1;;;;;36471:26:0;;;36504:32;;;;;;;;;;-1:-1:-1;36504:32:0;;;;-1:-1:-1;;;;;36504:32:0;;;27685:107;;;;;;;;;;-1:-1:-1;27685:107:0;;;;;:::i;:::-;;:::i;36186:35::-;;;;;;;;;;;;36220:1;36186:35;;49420:466;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;;;;;;;;;49607:1:::1;49597:7;:11;49589:53;;;::::0;-1:-1:-1;;;49589:53:0;;9675:2:1;49589:53:0::1;::::0;::::1;9657:21:1::0;9714:2;9694:18;;;9687:30;9753:31;9733:18;;;9726:59;9802:18;;49589:53:0::1;9647:179:1::0;49589:53:0::1;49653:18;:29:::0;;-1:-1:-1;;49653:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;49693:14:::1;:21:::0;;;;-1:-1:-1;49725:22:0::1;:26:::0;49762:17:::1;:27:::0;49800:22:::1;:32:::0;49866:12:::1;49843:20;:35:::0;49420:466::o;50958:382::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;51172:160:::1;51195:13;51223:11;51249:14;51278:13;51306:15;51172:8;:160::i;:::-;50958:382:::0;;;;;:::o;41023:94::-;41071:13;41104:5;41097:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41023:94;:::o;41448:248::-;41584:10;41550:4;41572:23;;;:11;:23;;;;;;;-1:-1:-1;;;;;41572:32:0;;;;;;;;;;:41;;;41629:37;41550:4;;41572:32;;41629:37;;;;41607:6;13099:25:1;;13087:2;13072:18;;13054:76;41629:37:0;;;;;;;;-1:-1:-1;41684:4:0;41448:248;;;;:::o;53937:182::-;54044:4;54105:6;54073:29;54093:8;54073:19;:29::i;:::-;:38;;53937:182;-1:-1:-1;;;53937:182:0:o;50846:104::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50922:14:0;;;::::1;;::::0;;;:9:::1;:14;::::0;;;;:20;;-1:-1:-1;;50922:20:0::1;::::0;::::1;;::::0;;;::::1;::::0;;50846:104::o;52820:280::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;52964:1:::1;52949:12;:16;52941:63;;;::::0;-1:-1:-1;;;52941:63:0;;11984:2:1;52941:63:0::1;::::0;::::1;11966:21:1::0;12023:2;12003:18;;;11996:30;12062:34;12042:18;;;12035:62;-1:-1:-1;;;12113:18:1;;;12106:32;12155:19;;52941:63:0::1;11956:224:1::0;52941:63:0::1;53015:15;:25:::0;;;;53051:26:::1;:41:::0;52820:280::o;49894:449::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;50071:7:::1;50061:6;:17;;50053:62;;;::::0;-1:-1:-1;;;50053:62:0;;10033:2:1;50053:62:0::1;::::0;::::1;10015:21:1::0;;;10052:18;;;10045:30;10111:34;10091:18;;;10084:62;10163:18;;50053:62:0::1;10005:182:1::0;50053:62:0::1;50161:1;50134:23;50146:11:::0;50134:9;:23:::1;:::i;:::-;:28;;:55;;;;;50178:11;50166:9;:23;50134:55;50126:64;;;::::0;::::1;;50201:26;:38:::0;;;;50250:28:::1;:42:::0;50303:23:::1;:32:::0;49894:449::o;42025:419::-;42215:12;;-1:-1:-1;;;;;42180:19:0;;42159:4;42180:19;;;:11;:19;;;;;;;42200:10;42180:31;;;;;;;;42159:4;;42180:47;42176:201;;42278:87;;;;;;;;;;;-1:-1:-1;;;42278:87:0;;;;;;;;-1:-1:-1;;;;;42278:19:0;;-1:-1:-1;42278:19:0;;;;;;;;;42298:10;42278:31;;;;;;;;;;:87;;42332:6;;42278:53;:87::i;:::-;-1:-1:-1;;;;;42244:19:0;;;;;;:11;:19;;;;;;;42264:10;42244:31;;;;;;;:121;42176:201;42396:40;42410:6;42418:9;42429:6;42396:13;:40::i;:::-;42389:47;;42025:419;;;;;;:::o;53580:142::-;41218:9;:18;;;;36270:6;53633:7;41218:18;;;;;53660:12;;53633:7;;53660:54;;41218:18;;53660:33;;:12;:16;:33::i;:::-;:37;;:54::i;:::-;53653:61;;53580:142;:::o;53108:207::-;27566:4;27601:5;-1:-1:-1;;;;;27601:5:0;26890:10;27590:16;26874:38;;;;-1:-1:-1;;;26874:38:0;;;;;;;:::i;:::-;53242:11:::1;::::0;:65:::1;::::0;-1:-1:-1;;;53242:65:0;;::::1;::::0;::::1;13896:25:1::0;;;13937:18;;;13930:34;;;-1:-1:-1;;;;;53242:11:0;;::::1;::::0;:35:::1;::::0;13869:18:1;;53242:65:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;53108:207:::0;;:::o;41704:117::-;41759:4;41783:30;41791:7;41800:12;;41783:7;:30::i;:::-;41776:37;41704:117;-1:-1:-1;;41704:117:0:o;50733:105::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50804:19:0::1;;::::0;;;:11:::1;:19;::::0;;;;:26;;-1:-1:-1;;50804:26:0::1;50826:4;50804:26;::::0;;50733:105::o;40917:98::-;40967:13;41000:7;40993:14;;;;;:::i;53323:249::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;53428:7:::1;53421:3;:14;;:32;;;;;53446:7;53439:3;:14;;53421:32;53399:134;;;::::0;-1:-1:-1;;;53399:134:0;;11229:2:1;53399:134:0::1;::::0;::::1;11211:21:1::0;11268:2;11248:18;;;11241:30;11307:34;11287:18;;;11280:62;-1:-1:-1;;;11358:18:1;;;11351:50;11418:19;;53399:134:0::1;11201:242:1::0;53399:134:0::1;53544:14;:20:::0;53323:249::o;41829:188::-;41936:4;41965:44;41979:10;41991:9;42002:6;41965:13;:44::i;48633:105::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;48729:1:::1;48698:28;:32:::0;48633:105::o;27184:94::-;27566:4;27601:5;-1:-1:-1;;;;;27601:5:0;26890:10;27590:16;26874:38;;;;-1:-1:-1;;;26874:38:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27244:19:0::1;;::::0;;;27266:4:::1;27244:19;::::0;;;;;;;:26;;-1:-1:-1;;27244:26:0::1;::::0;;::::1;::::0;;27184:94::o;53730:199::-;53825:7;53857:64;53898:22;:20;:22::i;:::-;53880:4;;-1:-1:-1;;;;;53880:4:0;41191:7;41218:18;;;:9;:18;;;;;;53857:36;;53870:22;;53890:1;53870:19;:22::i;:::-;53857:8;;:12;:36::i;:::-;:40;;:64::i;44356:859::-;44405:7;44516:15;44443:57;44476:23;;44443:28;;:32;;:57;;;;:::i;:::-;:88;44425:757;;;44558:21;44582:114;44680:15;44582:75;44633:23;;44582:28;;:50;;:75;;;;:::i;:114::-;44558:138;;44711:19;44733:142;44866:8;;44733:110;44814:28;;44733:58;44764:26;;44733:8;;:30;;:58;;;;:::i;:142::-;44711:164;;44892:20;44915:105;44946:59;44981:23;;44946:30;44962:13;44946:11;:15;;:30;;;;:::i;:59::-;44915:8;;;:12;:105::i;:::-;44892:128;;45091:1;45074:14;;:18;;;;:::i;:::-;45059:12;:33;:111;;45158:12;45059:111;;;45133:1;45116:14;;:18;;;;:::i;:::-;45035:135;;;;;44356:859;:::o;44425:757::-;-1:-1:-1;45199:8:0;;;44356:859::o;52470:342::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;52607:8:::1;:45;;;;;52645:7;52630:12;;:22;;;;:::i;:::-;52619:7;:33;;52607:45;52585:152;;;::::0;-1:-1:-1;;;52585:152:0;;10394:2:1;52585:152:0::1;::::0;::::1;10376:21:1::0;10433:2;10413:18;;;10406:30;10472:34;10452:18;;;10445:62;10543:27;10523:18;;;10516:55;10588:19;;52585:152:0::1;10366:247:1::0;52585:152:0::1;52748:11;:22:::0;;-1:-1:-1;;52748:22:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;52781:13:::1;:23:::0;52470:342::o;52021:441::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;52178:20:::1;::::0;-1:-1:-1;;;;;52153:45:0;;::::1;52178:20:::0;::::1;52153:45;;52131:135;;;::::0;-1:-1:-1;;;52131:135:0;;10820:2:1;52131:135:0::1;::::0;::::1;10802:21:1::0;10859:2;10839:18;;;10832:30;10898:34;10878:18;;;10871:62;-1:-1:-1;;;10949:18:1;;;10942:38;10997:19;;52131:135:0::1;10792:230:1::0;52131:135:0::1;-1:-1:-1::0;;;;;52300:32:0;::::1;11732:20:::0;11780:8;52277:122:::1;;;::::0;-1:-1:-1;;;52277:122:0;;9269:2:1;52277:122:0::1;::::0;::::1;9251:21:1::0;9308:2;9288:18;;;9281:30;9347:34;9327:18;;;9320:62;-1:-1:-1;;;9398:18:1;;;9391:35;9443:19;;52277:122:0::1;9241:227:1::0;52277:122:0::1;52410:20;:44:::0;;-1:-1:-1;;;;;;52410:44:0::1;-1:-1:-1::0;;;;;52410:44:0;;;::::1;::::0;;;::::1;::::0;;52021:441::o;27354:97::-;27566:4;27601:5;-1:-1:-1;;;;;27601:5:0;26890:10;27590:16;26874:38;;;;-1:-1:-1;;;26874:38:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27416:19:0::1;27438:5;27416:19:::0;;;:14:::1;:19;::::0;;;;:27;;-1:-1:-1;;27416:27:0::1;::::0;;27354:97::o;44174:174::-;44230:7;44254;44250:65;;;44285:18;:16;:18::i;44250:65::-;-1:-1:-1;;44332:8:0;;;44174:174::o;27911:173::-;27566:4;27601:5;-1:-1:-1;;;;;27601:5:0;26890:10;27590:16;26874:38;;;;-1:-1:-1;;;26874:38:0;;;;;;;:::i;:::-;27987:5:::1;:11:::0;;-1:-1:-1;;;;;;27987:11:0::1;-1:-1:-1::0;;;;;27987:11:0;::::1;::::0;;::::1;::::0;;28009:19;;;-1:-1:-1;28009:19:0::1;::::0;;;;;;;;:26;;-1:-1:-1;;28009:26:0::1;::::0;;::::1;::::0;;;28051:25;;5825:51:1;;;28051:25:0::1;::::0;5798:18:1;28051:25:0::1;;;;;;;27911:173:::0;:::o;48284:341::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;48413:23:::1;48423:6;36270;48413:9;:23::i;:::-;48451:24;48447:171;;;48523:15;48492:28;:46:::0;48582:23:::1;::::0;48558:48:::1;::::0;13099:25:1;;;48558:48:0::1;::::0;13087:2:1;13072:18;48558:48:0::1;;;;;;;48447:171;48284:341:::0;;:::o;50351:374::-;27060:24;27073:10;27060:12;:24::i;:::-;27052:48;;;;-1:-1:-1;;;27052:48:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50471:23:0;::::1;50489:4;50471:23;::::0;::::1;::::0;:41:::1;;-1:-1:-1::0;50508:4:0::1;::::0;-1:-1:-1;;;;;50498:14:0;;::::1;50508:4:::0;::::1;50498:14;;50471:41;50463:50;;;::::0;::::1;;-1:-1:-1::0;;;;;50524:24:0;::::1;;::::0;;;:16:::1;:24;::::0;;;;:33;;-1:-1:-1;;50524:33:0::1;::::0;::::1;::::0;::::1;::::0;;;::::1;::::0;;;50568:150:::1;;50595:11;::::0;:31:::1;::::0;-1:-1:-1;;;50595:31:0;;-1:-1:-1;;;;;6303:32:1;;;50595:31:0::1;::::0;::::1;6285:51:1::0;50595:11:0::1;6352:18:1::0;;;6345:34;50595:11:0;;::::1;::::0;:20:::1;::::0;6258:18:1;;50595:31:0::1;6240:145:1::0;50568:150:0::1;50659:11;::::0;-1:-1:-1;;;;;50688:17:0;;::::1;50659:11;50688:17:::0;;;:9:::1;:17;::::0;;;;;;;50659:47;;-1:-1:-1;;;50659:47:0;;::::1;::::0;::::1;6285:51:1::0;;;;6352:18;;;6345:34;50659:11:0;::::1;::::0;:20:::1;::::0;6258:18:1;;50659:47:0::1;6240:145:1::0;27685:107:0;-1:-1:-1;;;;;27765:19:0;27741:4;27765:19;;;:14;:19;;;;;;;;;27685:107::o;11409:387::-;11732:20;11780:8;;;11409:387::o;2837:98::-;2895:7;2922:5;2926:1;2922;:5;:::i;51348:665::-;51554:12;:28;;;51593:10;:24;;;51628:13;:30;;;51669:12;:28;;;51719:93;51684:13;51719:50;51644:14;51719:50;51569:13;51606:11;51719:17;:30::i;:::-;:34;;:50::i;:93::-;51708:8;:104;51823:14;:32;;;51900:18;51917:1;51840:15;51900:18;:::i;:::-;51888:8;;:30;;51866:139;;;;-1:-1:-1;;;51866:139:0;;12727:2:1;51866:139:0;;;12709:21:1;12766:2;12746:18;;;12739:30;12805:34;12785:18;;;12778:62;12876:29;12856:18;;;12849:57;12923:19;;51866:139:0;12699:249:1;5116:240:0;5236:7;5297:12;5289:6;;;;5281:29;;;;-1:-1:-1;;;5281:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;5332:5:0;;;5116:240::o;42452:1167::-;42599:6;;42578:4;;42599:6;;42595:87;;;42629:41;42644:6;42652:9;42663:6;42629:14;:41::i;:::-;42622:48;;;;42595:87;42698:16;:14;:16::i;:::-;42694:59;;;42731:10;:8;:10::i;:::-;42767:19;:17;:19::i;:::-;42763:72;;;42803:20;:18;:20::i;:::-;42867:90;;;;;;;;;;;-1:-1:-1;;;42867:90:0;;;;;;;;-1:-1:-1;;;;;42867:17:0;;-1:-1:-1;42867:17:0;;;:9;:17;;;;;;;;:90;;42903:6;;42867:21;:90::i;:::-;-1:-1:-1;;;;;42847:17:0;;;;;;:9;:17;;;;;:110;;;;42995:21;42857:6;42995:13;:21::i;:::-;:93;;43082:6;42995:93;;;43032:34;43040:6;43048:9;43059:6;43032:7;:34::i;:::-;-1:-1:-1;;;;;43124:20:0;;;;;;:9;:20;;;;;;42970:118;;-1:-1:-1;43124:40:0;;42970:118;43124:24;:40::i;:::-;-1:-1:-1;;;;;43101:20:0;;;;;;;:9;:20;;;;;;;;:63;;;;43182:24;;;;;:16;:24;;;;;;;43177:120;;43227:11;;-1:-1:-1;;;;;43256:17:0;;;43227:11;43256:17;;;:9;:17;;;;;;;;43227:47;;-1:-1:-1;;;43227:47:0;;;;;6285:51:1;;;;6352:18;;;6345:34;43227:11:0;;;:20;;6258:18:1;;43227:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43223:63;;-1:-1:-1;;;;;43312:27:0;;;;;;:16;:27;;;;;;;;43307:159;;43377:11;;-1:-1:-1;;;;;43409:20:0;;;43377:11;43409:20;;;:9;:20;;;;;;;;43377:53;;-1:-1:-1;;;43377:53:0;;;;;6285:51:1;;;;6352:18;;;6345:34;43377:11:0;;;:20;;6258:18:1;;43377:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43356:99;;43482:11;;43502:14;;43482:35;;-1:-1:-1;;;;;;43482:35:0;;-1:-1:-1;;;;;43482:11:0;;;;:19;;:35;;;;13099:25:1;;;13087:2;13072:18;;13054:76;43482:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43478:51;43563:9;-1:-1:-1;;;;;43546:43:0;43555:6;-1:-1:-1;;;;;43546:43:0;;43574:14;43546:43;;;;13099:25:1;;13087:2;13072:18;;13054:76;43546:43:0;;;;;;;;-1:-1:-1;43607:4:0;;42452:1167;-1:-1:-1;;;;42452:1167:0:o;3218:98::-;3276:7;3303:5;3307:1;3303;:5;:::i;3575:98::-;3633:7;3660:5;3664:1;3660;:5;:::i;3974:98::-;4032:7;4059:5;4063:1;4059;:5;:::i;49081:331::-;38111:6;:13;;-1:-1:-1;;38111:13:0;38120:4;38111:13;;;49181:16:::1;::::0;;49195:1:::1;49181:16:::0;;;;;::::1;::::0;;-1:-1:-1;;49181:16:0::1;::::0;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;49218:6:0::1;::::0;:13:::1;::::0;;-1:-1:-1;;;49218:13:0;;;;49157:40;;-1:-1:-1;;;;;;49218:6:0;;::::1;::::0;:11:::1;::::0;-1:-1:-1;49218:13:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;:6;:13;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49208:4;49213:1;49208:7;;;;;;-1:-1:-1::0;;;49208:7:0::1;;;;;;;;;;;;;;:23;-1:-1:-1::0;;;;;49208:23:0::1;;;-1:-1:-1::0;;;;;49208:23:0::1;;;::::0;::::1;49260:4;49242;49247:1;49242:7;;;;;;-1:-1:-1::0;;;49242:7:0::1;;;;;;;;;-1:-1:-1::0;;;;;49242:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;49278:6:::1;::::0;:126:::1;::::0;-1:-1:-1;;;49278:126:0;;:6;::::1;::::0;:57:::1;::::0;49357:6;;49278:126:::1;::::0;:6:::1;::::0;49378:4;;49384:2;;49388:15:::1;::::0;49278:126:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;38147:6:0;:14;;-1:-1:-1;;38147:14:0;;;-1:-1:-1;;;;;;49081:331:0:o;43627:401::-;43791:90;;;;;;;;;;;-1:-1:-1;;;43791:90:0;;;;;;;;-1:-1:-1;;;;;43791:17:0;;43754:4;43791:17;;;:9;:17;;;;;;;:90;;43827:6;;43791:21;:90::i;:::-;-1:-1:-1;;;;;43771:17:0;;;;;;;:9;:17;;;;;;:110;;;;43915:20;;;;;;;:32;;43940:6;43915:24;:32::i;:::-;-1:-1:-1;;;;;43892:20:0;;;;;;;:9;:20;;;;;;;:55;;;;43963:35;;;;;;;;;;43991:6;13099:25:1;;13087:2;13072:18;;13054:76;43963:35:0;;;;;;;;-1:-1:-1;44016:4:0;43627:401;;;;;:::o;45661:222::-;45761:4;;45710;;-1:-1:-1;;;;;45761:4:0;45747:10;:18;;;;:42;;-1:-1:-1;45783:6:0;;;;45782:7;45747:42;:70;;;;-1:-1:-1;45806:11:0;;;;45747:70;:128;;;;-1:-1:-1;;45862:13:0;;45852:4;45834:24;;;;:9;:24;;;;;;:41;;;45661:222::o;45891:2030::-;38111:6;:13;;-1:-1:-1;;38111:13:0;38120:4;38111:13;;;46000:15:::1;::::0;46030:26:::1;::::0;38111:6;;45970:97:::1;::::0;:15:::1;:97::i;:::-;:142;;46100:12;;45970:142;;;46083:1;45970:142;45940:172;;46123:23;46172:1:::0;46161:8:::1;;:12;46157:176;;;46208:113;46319:1;46208:88;46287:8;;46208:56;46244:19;46208:13;;:35;;:56;;;;:::i;:113::-;46190:131;;46157:176;46366:13;::::0;46343:20:::1;::::0;46366:34:::1;::::0;46384:15;46366:17:::1;:34::i;:::-;46437:16;::::0;;46451:1:::1;46437:16:::0;;;;;::::1;::::0;;46343:57;;-1:-1:-1;46413:21:0::1;::::0;46437:16;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;46437:16:0::1;46413:40;;46482:4;46464;46469:1;46464:7;;;;;;-1:-1:-1::0;;;46464:7:0::1;;;;;;;;;-1:-1:-1::0;;;;;46464:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;;:23;;;;46508:6:::1;::::0;:13:::1;::::0;;-1:-1:-1;;;46508:13:0;;;;:6;;;::::1;::::0;:11:::1;::::0;:13:::1;::::0;;::::1;::::0;46464:7;;46508:13;;;;;:6;:13;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46498:4;46503:1;46498:7;;;;;;-1:-1:-1::0;;;46498:7:0::1;;;;;;;;;-1:-1:-1::0;;;;;46498:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;46590:6:::1;::::0;:188:::1;::::0;-1:-1:-1;;;46590:188:0;;46556:21:::1;::::0;46590:6;;;::::1;::::0;:57:::1;::::0;:188:::1;::::0;46662:12;;46532:21:::1;::::0;46705:4;;46732::::1;::::0;46752:15:::1;::::0;46590:188:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;46791:17;46811:40;46837:13;46811:21;:25;;:40;;;;:::i;:::-;46791:60:::0;-1:-1:-1;46864:19:0::1;46886:40;46899:26;:19:::0;46923:1:::1;46899:23;:26::i;:::-;46886:8;::::0;;:12:::1;:40::i;:::-;46864:62:::0;-1:-1:-1;46939:26:0::1;46980:15:::0;;46976:579:::1;;47033:112;47143:1;47033:87;47108:11:::0;47033:87;:9;47065:19;47033:31:::1;:52::i;:112::-;47012:133;;47162:27;47192:77;47243:11;47192:28;47206:13;;47192:9;:13;;:28;;;;:::i;:77::-;47162:107;;47284:26;47313:76;47363:11;47313:27;47327:12;;47313:9;:13;;:27;;;;:::i;:76::-;47284:105;;47410:11;;;;;;;;;-1:-1:-1::0;;;;;47410:11:0::1;-1:-1:-1::0;;;;;47410:19:0::1;;47437;47410:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;47406:65:::0;47493:20:::1;::::0;47485:58:::1;::::0;-1:-1:-1;;;;;47493:20:0;;::::1;::::0;47485:58;::::1;;;::::0;47524:18;;47493:20:::1;47485:58:::0;47493:20;47485:58;47524:18;47493:20;47485:58;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;46976:579;;;47571:19:::0;;47567:347:::1;;47607:6;::::0;:227:::1;::::0;-1:-1:-1;;;47607:227:0;;47683:4:::1;47607:227;::::0;::::1;7010:34:1::0;7060:18;;;7053:34;;;47607:6:0::1;7103:18:1::0;;;7096:34;;;7146:18;;;7139:34;36270:6:0::1;7189:19:1::0;;;7182:44;47804:15:0::1;7242:19:1::0;;;7235:35;-1:-1:-1;;;;;47607:6:0;;::::1;::::0;:22:::1;::::0;47637:18;;6944:19:1;;47607:227:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;47854:48:0::1;::::0;;13896:25:1;;;13952:2;13937:18;;13930:34;;;47854:48:0::1;::::0;-1:-1:-1;13869:18:1;47854:48:0::1;;;;;;;-1:-1:-1::0;;38147:6:0;:14;;-1:-1:-1;;38147:14:0;;;-1:-1:-1;;;;;;45891:2030:0:o;47929:347::-;48032:4;;47981;;-1:-1:-1;;;;;48032:4:0;48018:10;:18;;;;:42;;-1:-1:-1;48054:6:0;;;;48053:7;48018:42;:77;;;;-1:-1:-1;48077:18:0;;;;48018:77;:155;;;;;48161:12;48135:22;;48112:20;;:45;;;;:::i;:::-;:61;;48018:155;:250;;;;-1:-1:-1;;48251:17:0;;48226:21;:42;;;47929:347::o;48746:327::-;48796:34;48806:17;;36270:6;48796:9;:34::i;:::-;48864:12;48841:20;:35;48939:17;;48912:22;;:45;;:26;:45::i;:::-;48887:22;:70;;;48997:14;;-1:-1:-1;48968:98:0;;;49028:18;:26;;-1:-1:-1;;49028:26:0;;;48968:98;48746:327::o;44036:130::-;-1:-1:-1;;;;;44123:19:0;;44098:4;44123:19;;;:11;:19;;;;;;;;44122:20;:36;;;;;44157:1;44146:8;;:12;44115:43;44036:130;-1:-1:-1;;44036:130:0:o;45223:430::-;45442:14;;45417:4;;45342:7;;;;45382:85;;45442:14;45382:41;;45393:29;;-1:-1:-1;;;;;45405:16:0;;;45417:4;;45405:16;45393:11;:29::i;:::-;45382:6;;:10;:41::i;:85::-;45525:4;45507:24;;;;:9;:24;;;;;;45362:105;;-1:-1:-1;45507:39:0;;45362:105;45507:28;:39::i;:::-;45498:4;45480:24;;;;:9;:24;;;;;;;:66;;;;45562:42;;-1:-1:-1;;;;;45562:42:0;;;;;;;45594:9;13099:25:1;;13087:2;13072:18;;13054:76;45562:42:0;;;;;;;;45624:21;:6;45635:9;45624:10;:21::i;:::-;45617:28;45223:430;-1:-1:-1;;;;;45223:430:0:o;14:160:1:-;79:20;;135:13;;128:21;118:32;;108:2;;164:1;161;154:12;108:2;60:114;;;:::o;179:257::-;238:6;291:2;279:9;270:7;266:23;262:32;259:2;;;312:6;304;297:22;259:2;356:9;343:23;375:31;400:5;375:31;:::i;441:261::-;511:6;564:2;552:9;543:7;539:23;535:32;532:2;;;585:6;577;570:22;532:2;622:9;616:16;641:31;666:5;641:31;:::i;977:398::-;1045:6;1053;1106:2;1094:9;1085:7;1081:23;1077:32;1074:2;;;1127:6;1119;1112:22;1074:2;1171:9;1158:23;1190:31;1215:5;1190:31;:::i;:::-;1240:5;-1:-1:-1;1297:2:1;1282:18;;1269:32;1310:33;1269:32;1310:33;:::i;:::-;1362:7;1352:17;;;1064:311;;;;;:::o;1380:466::-;1457:6;1465;1473;1526:2;1514:9;1505:7;1501:23;1497:32;1494:2;;;1547:6;1539;1532:22;1494:2;1591:9;1578:23;1610:31;1635:5;1610:31;:::i;:::-;1660:5;-1:-1:-1;1717:2:1;1702:18;;1689:32;1730:33;1689:32;1730:33;:::i;:::-;1484:362;;1782:7;;-1:-1:-1;;;1836:2:1;1821:18;;;;1808:32;;1484:362::o;1851:325::-;1916:6;1924;1977:2;1965:9;1956:7;1952:23;1948:32;1945:2;;;1998:6;1990;1983:22;1945:2;2042:9;2029:23;2061:31;2086:5;2061:31;:::i;:::-;2111:5;-1:-1:-1;2135:35:1;2166:2;2151:18;;2135:35;:::i;:::-;2125:45;;1935:241;;;;;:::o;2181:325::-;2249:6;2257;2310:2;2298:9;2289:7;2285:23;2281:32;2278:2;;;2331:6;2323;2316:22;2278:2;2375:9;2362:23;2394:31;2419:5;2394:31;:::i;:::-;2444:5;2496:2;2481:18;;;;2468:32;;-1:-1:-1;;;2268:238:1:o;2511:190::-;2567:6;2620:2;2608:9;2599:7;2595:23;2591:32;2588:2;;;2641:6;2633;2626:22;2588:2;2669:26;2685:9;2669:26;:::i;2706:258::-;2771:6;2779;2832:2;2820:9;2811:7;2807:23;2803:32;2800:2;;;2853:6;2845;2838:22;2800:2;2881:26;2897:9;2881:26;:::i;2969:395::-;3052:6;3060;3068;3076;3129:3;3117:9;3108:7;3104:23;3100:33;3097:2;;;3151:6;3143;3136:22;3097:2;3179:26;3195:9;3179:26;:::i;:::-;3169:36;3252:2;3237:18;;3224:32;;-1:-1:-1;3303:2:1;3288:18;;3275:32;;3354:2;3339:18;3326:32;;-1:-1:-1;3087:277:1;-1:-1:-1;;;3087:277:1:o;3369:190::-;3428:6;3481:2;3469:9;3460:7;3456:23;3452:32;3449:2;;;3502:6;3494;3487:22;3449:2;-1:-1:-1;3530:23:1;;3439:120;-1:-1:-1;3439:120:1:o;3564:258::-;3629:6;3637;3690:2;3678:9;3669:7;3665:23;3661:32;3658:2;;;3711:6;3703;3696:22;3658:2;3752:9;3739:23;3729:33;;3781:35;3812:2;3801:9;3797:18;3781:35;:::i;3827:258::-;3895:6;3903;3956:2;3944:9;3935:7;3931:23;3927:32;3924:2;;;3977:6;3969;3962:22;3924:2;-1:-1:-1;;4005:23:1;;;4075:2;4060:18;;;4047:32;;-1:-1:-1;3914:171:1:o;4090:326::-;4167:6;4175;4183;4236:2;4224:9;4215:7;4211:23;4207:32;4204:2;;;4257:6;4249;4242:22;4204:2;-1:-1:-1;;4285:23:1;;;4355:2;4340:18;;4327:32;;-1:-1:-1;4406:2:1;4391:18;;;4378:32;;4194:222;-1:-1:-1;4194:222:1:o;4421:316::-;4509:6;4517;4525;4578:2;4566:9;4557:7;4553:23;4549:32;4546:2;;;4599:6;4591;4584:22;4546:2;4633:9;4627:16;4617:26;;4683:2;4672:9;4668:18;4662:25;4652:35;;4727:2;4716:9;4712:18;4706:25;4696:35;;4536:201;;;;;:::o;4742:464::-;4837:6;4845;4853;4861;4869;4922:3;4910:9;4901:7;4897:23;4893:33;4890:2;;;4944:6;4936;4929:22;4890:2;-1:-1:-1;;4972:23:1;;;5042:2;5027:18;;5014:32;;-1:-1:-1;5093:2:1;5078:18;;5065:32;;5144:2;5129:18;;5116:32;;-1:-1:-1;5195:3:1;5180:19;5167:33;;-1:-1:-1;4880:326:1;-1:-1:-1;4880:326:1:o;5211:463::-;5264:3;5302:5;5296:12;5329:6;5324:3;5317:19;5355:4;5384:2;5379:3;5375:12;5368:19;;5421:2;5414:5;5410:14;5442:3;5454:195;5468:6;5465:1;5462:13;5454:195;;;5533:13;;-1:-1:-1;;;;;5529:39:1;5517:52;;5589:12;;;;5624:15;;;;5565:1;5483:9;5454:195;;;-1:-1:-1;5665:3:1;;5272:402;-1:-1:-1;;;;;5272:402:1:o;7944:510::-;8215:6;8204:9;8197:25;8258:3;8253:2;8242:9;8238:18;8231:31;8178:4;8279:57;8331:3;8320:9;8316:19;8308:6;8279:57;:::i;:::-;-1:-1:-1;;;;;8372:32:1;;;;8367:2;8352:18;;8345:60;-1:-1:-1;8436:2:1;8421:18;8414:34;8271:65;8187:267;-1:-1:-1;;8187:267:1:o;8459:603::-;8571:4;8600:2;8629;8618:9;8611:21;8661:6;8655:13;8704:6;8699:2;8688:9;8684:18;8677:34;8729:4;8742:140;8756:6;8753:1;8750:13;8742:140;;;8851:14;;;8847:23;;8841:30;8817:17;;;8836:2;8813:26;8806:66;8771:10;;8742:140;;;8900:6;8897:1;8894:13;8891:2;;;8970:4;8965:2;8956:6;8945:9;8941:22;8937:31;8930:45;8891:2;-1:-1:-1;9046:2:1;9025:15;-1:-1:-1;;9021:29:1;9006:45;;;;9053:2;9002:54;;8580:482;-1:-1:-1;;;8580:482:1:o;11448:329::-;11650:2;11632:21;;;11689:1;11669:18;;;11662:29;-1:-1:-1;;;11722:2:1;11707:18;;11700:36;11768:2;11753:18;;11622:155::o;12185:335::-;12387:2;12369:21;;;12426:2;12406:18;;;12399:30;-1:-1:-1;;;12460:2:1;12445:18;;12438:41;12511:2;12496:18;;12359:161::o;13135:582::-;13434:6;13423:9;13416:25;13477:6;13472:2;13461:9;13457:18;13450:34;13520:3;13515:2;13504:9;13500:18;13493:31;13397:4;13541:57;13593:3;13582:9;13578:19;13570:6;13541:57;:::i;:::-;-1:-1:-1;;;;;13634:32:1;;;;13629:2;13614:18;;13607:60;-1:-1:-1;13698:3:1;13683:19;13676:35;13533:65;13406:311;-1:-1:-1;;;13406:311:1:o;14164:128::-;14204:3;14235:1;14231:6;14228:1;14225:13;14222:2;;;14241:18;;:::i;:::-;-1:-1:-1;14277:9:1;;14212:80::o;14297:217::-;14337:1;14363;14353:2;;-1:-1:-1;;;14388:31:1;;14442:4;14439:1;14432:15;14470:4;14395:1;14460:15;14353:2;-1:-1:-1;14499:9:1;;14343:171::o;14519:168::-;14559:7;14625:1;14621;14617:6;14613:14;14610:1;14607:21;14602:1;14595:9;14588:17;14584:45;14581:2;;;14632:18;;:::i;:::-;-1:-1:-1;14672:9:1;;14571:116::o;14692:125::-;14732:4;14760:1;14757;14754:8;14751:2;;;14765:18;;:::i;:::-;-1:-1:-1;14802:9:1;;14741:76::o;14822:380::-;14901:1;14897:12;;;;14944;;;14965:2;;15019:4;15011:6;15007:17;14997:27;;14965:2;15072;15064:6;15061:14;15041:18;15038:38;15035:2;;;15118:10;15113:3;15109:20;15106:1;15099:31;15153:4;15150:1;15143:15;15181:4;15178:1;15171:15;15035:2;;14877:325;;;:::o;15207:127::-;15268:10;15263:3;15259:20;15256:1;15249:31;15299:4;15296:1;15289:15;15323:4;15320:1;15313:15;15339:131;-1:-1:-1;;;;;15414:31:1;;15404:42;;15394:2;;15460:1;15457;15450:12;15394:2;15384:86;:::o

Swarm Source

ipfs://ed920347aec7c9fad5e52a9669a33e6c7bbb8ebc5f39973bbfe2ac8bf61ed277

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services