MATIC Price: $0.68 (+0.06%)
Gas: 67 GWei
 
Transaction Hash
Method
Block
From
To
Value
Transfer545314072024-03-11 13:08:3639 days ago1710162516IN
ShibPlus: SP Token
0 MATIC0.13563318362.1385059
Approve543784702024-03-07 15:59:1043 days ago1709827150IN
ShibPlus: SP Token
0 MATIC0.00912853196.3
Transfer542770882024-03-05 1:43:5645 days ago1709603036IN
ShibPlus: SP Token
0 MATIC0.04131954106.22046184
Approve542083092024-03-03 7:14:2247 days ago1709450062IN
ShibPlus: SP Token
0 MATIC0.00512928110.3
Approve540981512024-02-29 12:38:0550 days ago1709210285IN
ShibPlus: SP Token
0 MATIC0.0045107997
Approve540980802024-02-29 12:35:3450 days ago1709210134IN
ShibPlus: SP Token
0 MATIC0.00489826105.33233234
Approve540979952024-02-29 12:32:3250 days ago1709209952IN
ShibPlus: SP Token
0 MATIC0.00543362117.63386041
Approve540978492024-02-29 12:27:2250 days ago1709209642IN
ShibPlus: SP Token
0 MATIC0.00559194120.40450047
Approve540978372024-02-29 12:26:5650 days ago1709209616IN
ShibPlus: SP Token
0 MATIC0.00605757131.14190148
Approve540474062024-02-28 6:04:5951 days ago1709100299IN
ShibPlus: SP Token
0 MATIC0.002275686.59404429
Approve540473932024-02-28 6:04:3351 days ago1709100273IN
ShibPlus: SP Token
0 MATIC0.0024580893.53790201
Approve540187552024-02-27 12:11:2952 days ago1709035889IN
ShibPlus: SP Token
0 MATIC0.0019313173.49288031
Approve538617022024-02-23 11:57:5556 days ago1708689475IN
ShibPlus: SP Token
0 MATIC0.0039541185.62590856
Approve538595972024-02-23 10:42:2256 days ago1708684942IN
ShibPlus: SP Token
0 MATIC0.0043728594.6935632
Approve538594782024-02-23 10:38:1056 days ago1708684690IN
ShibPlus: SP Token
0 MATIC0.0034033773.69959191
Approve537803962024-02-21 10:19:0658 days ago1708510746IN
ShibPlus: SP Token
0 MATIC0.00821336177.85931735
Approve537803322024-02-21 10:16:2458 days ago1708510584IN
ShibPlus: SP Token
0 MATIC0.00612708132.68113361
Transfer537802232024-02-21 10:12:2558 days ago1708510345IN
ShibPlus: SP Token
0 MATIC0.0770117162.54121123
Approve536971392024-02-19 6:43:4660 days ago1708325026IN
ShibPlus: SP Token
0 MATIC0.00277495114.57751832
Transfer536499582024-02-18 2:04:0761 days ago1708221847IN
ShibPlus: SP Token
0 MATIC0.011815446.17122477
Transfer536497872024-02-18 1:57:3161 days ago1708221451IN
ShibPlus: SP Token
0 MATIC0.0147240746.97918546
Approve532180022024-02-07 4:02:0472 days ago1707278524IN
ShibPlus: SP Token
0 MATIC0.0014587331.36853392
Approve532180002024-02-07 4:02:0072 days ago1707278520IN
ShibPlus: SP Token
0 MATIC0.0014590231.37490905
Approve529599212024-01-31 11:32:2079 days ago1706700740IN
ShibPlus: SP Token
0 MATIC0.00361149149.11830406
Approve529598952024-01-31 11:31:0879 days ago1706700668IN
ShibPlus: SP Token
0 MATIC0.00905441194.70602829
View all transactions

Latest 25 internal transactions (View All)

Parent Txn Hash Block From To Value
412589682023-04-07 17:32:08378 days ago1680888728
ShibPlus: SP Token
5.1 MATIC
412554192023-04-07 15:23:44378 days ago1680881024
ShibPlus: SP Token
5.1 MATIC
412543162023-04-07 14:43:45378 days ago1680878625
ShibPlus: SP Token
5.1 MATIC
412538692023-04-07 14:27:23378 days ago1680877643
ShibPlus: SP Token
5.1 MATIC
412518532023-04-07 13:12:47378 days ago1680873167
ShibPlus: SP Token
5.1 MATIC
412512002023-04-07 12:48:36378 days ago1680871716
ShibPlus: SP Token
5.1 MATIC
412501242023-04-07 12:09:24378 days ago1680869364
ShibPlus: SP Token
5.1 MATIC
412476662023-04-07 10:38:23378 days ago1680863903
ShibPlus: SP Token
5.1 MATIC
412464992023-04-07 9:55:27378 days ago1680861327
ShibPlus: SP Token
5.1 MATIC
412447942023-04-07 8:50:49378 days ago1680857449
ShibPlus: SP Token
5.1 MATIC
412440562023-04-07 8:23:05378 days ago1680855785
ShibPlus: SP Token
5.1 MATIC
412432782023-04-07 7:54:25378 days ago1680854065
ShibPlus: SP Token
5.1 MATIC
412424972023-04-07 7:25:13378 days ago1680852313
ShibPlus: SP Token
5.1 MATIC
412418302023-04-07 7:00:31378 days ago1680850831
ShibPlus: SP Token
5.1 MATIC
412405372023-04-07 6:14:11378 days ago1680848051
ShibPlus: SP Token
5.1 MATIC
412383092023-04-07 4:53:41378 days ago1680843221
ShibPlus: SP Token
5.1 MATIC
412376322023-04-07 4:29:11378 days ago1680841751
ShibPlus: SP Token
5.1 MATIC
412370322023-04-07 4:07:23378 days ago1680840443
ShibPlus: SP Token
5.1 MATIC
412349222023-04-07 2:51:24378 days ago1680835884
ShibPlus: SP Token
5.1 MATIC
412336442023-04-07 2:03:38378 days ago1680833018
ShibPlus: SP Token
5.1 MATIC
411641272023-04-05 7:27:29380 days ago1680679649
ShibPlus: SP Token
5.1 MATIC
411610122023-04-05 5:29:49380 days ago1680672589
ShibPlus: SP Token
5.1 MATIC
411575632023-04-05 3:20:43380 days ago1680664843
ShibPlus: SP Token
5.1 MATIC
411549612023-04-05 1:44:19380 days ago1680659059
ShibPlus: SP Token
5.1 MATIC
411543572023-04-05 1:21:58380 days ago1680657718
ShibPlus: SP Token
5.1 MATIC
View All Internal Transactions
Loading...
Loading

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

Contract Name:
AntiBotBuybackBabyToken

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com 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/interfaces/IPinkAntiBot.sol

// pragma solidity >=0.5.0;

interface IPinkAntiBot {
  function setTokenOwner(address owner) external;

  function onPreTransferCheck(
    address from,
    address to,
    uint256 amount
  ) external;
}


// 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/AntiBotBuybackBabyToken.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/interfaces/IPinkAntiBot.sol";
// import "contracts/buyback/Auth.sol";
// import "contracts/buyback/DividendDistributor.sol";
// import "contracts/BaseToken.sol";

contract AntiBotBuybackBabyToken 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;

    IPinkAntiBot public pinkAntiBot;
    bool public enableAntiBot;

    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_,
        address antiBot_,
        uint256[5] memory feeSettings_,
        address serviceFeeReceiver_,
        uint256 serviceFee_
    ) payable Auth(msg.sender) {
        _name = name_;
        _symbol = symbol_;
        _totalSupply = totalSupply_;

        pinkAntiBot = IPinkAntiBot(antiBot_);
        pinkAntiBot.setTokenOwner(msg.sender);
        enableAntiBot = true;

        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.antiBotBuybackBaby,
            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;
    }

    function setEnableAntiBot(bool _enable) external authorized {
        enableAntiBot = _enable;
    }

    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 (enableAntiBot) {
            pinkAntiBot.onPreTransferCheck(sender, recipient, amount);
        }

        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

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":"address","name":"antiBot_","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":"enableAntiBot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"pinkAntiBot","outputs":[{"internalType":"contract IPinkAntiBot","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":"bool","name":"_enable","type":"bool"}],"name":"setEnableAntiBot","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"}]

Deployed Bytecode

0x6080604052600436106103dd5760003560e01c80636e78eb49116101fd578063d51ed1c811610118578063f0b37c04116100ab578063f708a64f1161007a578063f708a64f14610b3d578063f7c618c114610b5d578063f887ea4014610b7d578063fe9fbb8014610b9d578063ffa1ad7414610bbd57600080fd5b8063f0b37c0414610abd578063f1f3bca314610add578063f2fde38b14610afd578063f5cfec0a14610b1d57600080fd5b8063e01bb688116100e7578063e01bb68814610a37578063e96fada214610a57578063ecbf666f14610a77578063eff0dc2214610a8d57600080fd5b8063d51ed1c81461099e578063d806d12f146109be578063dd62ed3e146109d3578063df20fd4914610a1757600080fd5b806398118cb411610190578063b210b06d1161015f578063b210b06d14610933578063b6a5d7de14610948578063b91854f414610968578063bfe109281461097e57600080fd5b806398118cb4146108bd5780639d1944f5146108d3578063a8aa1b31146108f3578063a9059cbb1461091357600080fd5b80638ab6ffc7116101cc5780638ab6ffc714610866578063921250d11461087c57806392258ec81461089257806395d89b41146108a857600080fd5b80636e78eb49146107e457806370a08231146107fa57806383ad79941461083057806387406b331461084657600080fd5b8063241ec3be116102f8578063407133d21161028b578063591cf08d1161025a578063591cf08d146107725780635a53c1fb1461078857806360e719621461079e5780636b67c4df146107b45780636ddd1713146107ca57600080fd5b8063407133d2146106d45780634355855a1461070c5780634896a6321461073c578063571ac8b01461075257600080fd5b8063313ce567116102c7578063313ce567146106585780633b2d081c146106745780633bb8a8d41461068a5780633f4218e0146106a457600080fd5b8063241ec3be146105d35780632b112e49146105f45780632d48e896146106095780632f54bf6e1461062957600080fd5b8063180b0d7e116103705780631f46b1c61161033f5780631f46b1c614610553578063201e7991146105735780632375ce401461059357806323b872dd146105b357600080fd5b8063180b0d7e146104fc57806318160ddd1461051257806319be947b146105275780631df4ccfc1461053d57600080fd5b8063095ea7b3116103ac578063095ea7b3146104765780631023d5d4146104a65780631161ae39146104bc57806317d43583146104dc57600080fd5b80630445b667146103e9578063048c7baf1461041257806304a66b481461043457806306fdde031461045457600080fd5b366103e457005b600080fd5b3480156103f557600080fd5b506103ff601e5481565b6040519081526020015b60405180910390f35b34801561041e57600080fd5b5061043261042d3660046126bf565b610bd2565b005b34801561044057600080fd5b5061043261044f3660046127aa565b610c79565b34801561046057600080fd5b50610469610cb2565b604051610409919061285c565b34801561048257600080fd5b5061049661049136600461265f565b610d44565b6040519015158152602001610409565b3480156104b257600080fd5b506103ff60145481565b3480156104c857600080fd5b506104966104d7366004612731565b610dae565b3480156104e857600080fd5b506104326104f736600461262b565b610dc2565b34801561050857600080fd5b506103ff600e5481565b34801561051e57600080fd5b506004546103ff565b34801561053357600080fd5b506103ff60135481565b34801561054957600080fd5b506103ff600d5481565b34801561055f57600080fd5b5061043261056e36600461268a565b610e12565b34801561057f57600080fd5b5061043261058e366004612731565b610e55565b34801561059f57600080fd5b506104326105ae366004612752565b610ee0565b3480156105bf57600080fd5b506104966105ce3660046125eb565b610f87565b3480156105df57600080fd5b5060245461049690600160a01b900460ff1681565b34801561060057600080fd5b506103ff611046565b34801561061557600080fd5b50610432610624366004612731565b6110b7565b34801561063557600080fd5b5061049661064436600461257b565b6000546001600160a01b0391821691161490565b34801561066457600080fd5b5060405160098152602001610409565b34801561068057600080fd5b506103ff600a5481565b34801561069657600080fd5b506015546104969060ff1681565b3480156106b057600080fd5b506104966106bf36600461257b565b60226020526000908152604090205460ff1681565b3480156106e057600080fd5b506024546106f4906001600160a01b031681565b6040516001600160a01b039091168152602001610409565b34801561071857600080fd5b5061049661072736600461257b565b60236020526000908152604090205460ff1681565b34801561074857600080fd5b506103ff60185481565b34801561075e57600080fd5b5061049661076d36600461257b565b61114b565b34801561077e57600080fd5b506103ff60165481565b34801561079457600080fd5b506103ff60195481565b3480156107aa57600080fd5b506103ff601c5481565b3480156107c057600080fd5b506103ff600c5481565b3480156107d657600080fd5b50601d546104969060ff1681565b3480156107f057600080fd5b506103ff60175481565b34801561080657600080fd5b506103ff61081536600461257b565b6001600160a01b03166000908152601f602052604090205490565b34801561083c57600080fd5b506103ff600b5481565b34801561085257600080fd5b5061043261086136600461257b565b61115f565b34801561087257600080fd5b506103ff60105481565b34801561088857600080fd5b506103ff60115481565b34801561089e57600080fd5b506103ff600f5481565b3480156108b457600080fd5b506104696111a8565b3480156108c957600080fd5b506103ff60095481565b3480156108df57600080fd5b506104326108ee3660046126f7565b6111b7565b3480156108ff57600080fd5b506007546106f4906001600160a01b031681565b34801561091f57600080fd5b5061049661092e36600461265f565b611260565b34801561093f57600080fd5b5061043261126d565b34801561095457600080fd5b5061043261096336600461257b565b611299565b34801561097457600080fd5b506103ff601a5481565b34801561098a57600080fd5b50601b546106f4906001600160a01b031681565b3480156109aa57600080fd5b506103ff6109b93660046126f7565b6112ea565b3480156109ca57600080fd5b506103ff61132e565b3480156109df57600080fd5b506103ff6109ee3660046125b3565b6001600160a01b0391821660009081526020808052604080832093909416825291909152205490565b348015610a2357600080fd5b50610432610a323660046126a4565b6113f6565b348015610a4357600080fd5b50610432610a5236600461257b565b6114c1565b348015610a6357600080fd5b506008546106f4906001600160a01b031681565b348015610a8357600080fd5b506103ff60125481565b348015610a9957600080fd5b50610496610aa836600461257b565b60216020526000908152604090205460ff1681565b348015610ac957600080fd5b50610432610ad836600461257b565b6115dd565b348015610ae957600080fd5b506103ff610af836600461268a565b611628565b348015610b0957600080fd5b50610432610b1836600461257b565b611640565b348015610b2957600080fd5b50610432610b3836600461270f565b6116d6565b348015610b4957600080fd5b50610432610b5836600461262b565b61174c565b348015610b6957600080fd5b506005546106f4906001600160a01b031681565b348015610b8957600080fd5b506006546106f4906001600160a01b031681565b348015610ba957600080fd5b50610496610bb836600461257b565b611850565b348015610bc957600080fd5b506103ff600281565b610bdb33611850565b610c005760405162461bcd60e51b8152600401610bf7906128cf565b60405180910390fd5b60008111610c505760405162461bcd60e51b815260206004820152601d60248201527f506572696f64206d7573742062652067726561746572207468616e20300000006044820152606401610bf7565b6015805460ff191694151594909417909355601691909155600060175560185560195543601a55565b610c8233611850565b610c9e5760405162461bcd60e51b8152600401610bf7906128cf565b610cab8585858585611880565b5050505050565b606060028054610cc19061299e565b80601f0160208091040260200160405190810160405280929190818152602001828054610ced9061299e565b8015610d3a5780601f10610d0f57610100808354040283529160200191610d3a565b820191906000526020600020905b815481529060010190602001808311610d1d57829003601f168201915b5050505050905090565b336000818152602080805260408083206001600160a01b038716808552925280832085905551919290917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92590610d9d9086815260200190565b60405180910390a350600192915050565b600082610dba836112ea565b119392505050565b610dcb33611850565b610de75760405162461bcd60e51b8152600401610bf7906128cf565b6001600160a01b03919091166000908152602160205260409020805460ff1916911515919091179055565b610e1b33611850565b610e375760405162461bcd60e51b8152600401610bf7906128cf565b60248054911515600160a01b0260ff60a01b19909216919091179055565b610e5e33611850565b610e7a5760405162461bcd60e51b8152600401610bf7906128cf565b60008111610ed55760405162461bcd60e51b815260206004820152602260248201527f44656e6f6d696e61746f72206d7573742062652067726561746572207468616e604482015261020360f41b6064820152608401610bf7565b600f91909155601055565b610ee933611850565b610f055760405162461bcd60e51b8152600401610bf7906128cf565b611c20811115610f575760405162461bcd60e51b815260206004820181905260248201527f4c656e677468206d757374206265206c657373207468616e203220686f7572736044820152606401610bf7565b6002610f638385612948565b11158015610f7057508183115b610f7957600080fd5b601192909255601255601455565b6004546001600160a01b038416600090815260208080526040808320338452909152812054909114611031576040805180820182526016815275496e73756666696369656e7420416c6c6f77616e636560501b6020808301919091526001600160a01b0387166000908152818052838120338252909152919091205461100e918490611934565b6001600160a01b0385166000908152602080805260408083203384529091529020555b61103c848484611960565b90505b9392505050565b601f6020527f8c60882dec3cf54096060609fdd16c336781b436ca34f3f27a220dfcfa1d48555461dead60009081527fef94442dfc0e910ca743614215a10fad3ff708bf5378f9c5c958c9192b3bf0045460045491926110b29290916110ac9190611cd7565b90611cd7565b905090565b6000546001600160a01b031633146110e15760405162461bcd60e51b8152600401610bf7906128af565b601b546040516316a4744b60e11b815260048101849052602481018390526001600160a01b0390911690632d48e896906044015b600060405180830381600087803b15801561112f57600080fd5b505af1158015611143573d6000803e3d6000fd5b505050505050565b600061115982600454610d44565b92915050565b61116833611850565b6111845760405162461bcd60e51b8152600401610bf7906128cf565b6001600160a01b03166000908152602260205260409020805460ff19166001179055565b606060038054610cc19061299e565b6111c033611850565b6111dc5760405162461bcd60e51b8152600401610bf7906128cf565b62030d4081101580156111f257506207a1208111155b61125b5760405162461bcd60e51b815260206004820152603460248201527f676173466f7250726f63657373696e67206d757374206265206265747765656e6044820152730203230302c30303020616e64203530302c3030360641b6064820152608401610bf7565b601c55565b600061103f338484611960565b61127633611850565b6112925760405162461bcd60e51b8152600401610bf7906128cf565b6000601355565b6000546001600160a01b031633146112c35760405162461bcd60e51b8152600401610bf7906128af565b6001600160a01b03166000908152600160208190526040909120805460ff19169091179055565b60006111596112f7611046565b6007546001600160a01b03166000908152601f602052604090205461132890611321906002611ce3565b8590611ce3565b90611cef565b60004261134860145460135461187490919063ffffffff16565b11156113ef57600061136b426110ac60145460135461187490919063ffffffff16565b90506000611392600d546110ac601254611328601154600d54611ce390919063ffffffff16565b905060006113bb6113b26014546113288686611ce390919063ffffffff16565b600d5490611874565b90506004600e546113cc9190612948565b81116113d857806113e7565b6004600e546113e79190612948565b935050505090565b50600d5490565b6113ff33611850565b61141b5760405162461bcd60e51b8152600401610bf7906128cf565b8180156114385750620186a06004546114349190612948565b8110155b6114aa5760405162461bcd60e51b815260206004820152603960248201527f537761706261636b20616d6f756e742073686f756c64206265206174206c656160448201527f737420302e30303125206f6620746f74616c20737570706c79000000000000006064820152608401610bf7565b601d805460ff191692151592909217909155601e55565b6114ca33611850565b6114e65760405162461bcd60e51b8152600401610bf7906128cf565b6008546001600160a01b03828116911614156115555760405162461bcd60e51b815260206004820152602860248201527f4d61726b6574696e672077616c6c657420697320616c72656164792074686174604482015267206164647265737360c01b6064820152608401610bf7565b6001600160a01b0381163b156115bb5760405162461bcd60e51b815260206004820152602560248201527f4d61726b6574696e672077616c6c65742063616e6e6f74206265206120636f6e6044820152641d1c9858dd60da1b6064820152608401610bf7565b600880546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b031633146116075760405162461bcd60e51b8152600401610bf7906128af565b6001600160a01b03166000908152600160205260409020805460ff19169055565b600081156116385761115961132e565b5050600d5490565b6000546001600160a01b0316331461166a5760405162461bcd60e51b8152600401610bf7906128af565b600080546001600160a01b0319166001600160a01b038316908117825580825260016020818152604093849020805460ff191690921790915591519081527f04dba622d284ed0014ee4b9a6a68386be1a4c08a4913ae272de89199cc686163910160405180910390a150565b6116df33611850565b6116fb5760405162461bcd60e51b8152600401610bf7906128cf565b6117078261dead611cfb565b801561174857426013556014546040519081527f39d2389ec5c1fa77b2c0d374bc61b6d7bd97ccba280fcdeb4e9c7644898d7c3a9060200160405180910390a15b5050565b61175533611850565b6117715760405162461bcd60e51b8152600401610bf7906128cf565b6001600160a01b038216301480159061179857506007546001600160a01b03838116911614155b6117a157600080fd5b6001600160a01b0382166000908152602360205260409020805460ff1916821580159190911790915561180757601b54604051630a5b654b60e11b81526001600160a01b03848116600483015260006024830152909116906314b6ca9690604401611115565b601b546001600160a01b038381166000818152601f602052604090819020549051630a5b654b60e11b8152600481019290925260248201529116906314b6ca9690604401611115565b6001600160a01b031660009081526001602052604090205460ff1690565b3b151590565b600061103f8284612930565b6009859055600a849055600b839055600c8290556118aa826118a485818989611874565b90611874565b600d55600e8190556118bd600482612948565b600d541115610cab5760405162461bcd60e51b815260206004820152603b60248201527f546f74616c206665652073686f756c64206e6f7420626520677265617465722060448201527f7468616e20312f34206f66206665652064656e6f6d696e61746f7200000000006064820152608401610bf7565b600081848411156119585760405162461bcd60e51b8152600401610bf7919061285c565b505050900390565b602454600090600160a01b900460ff16156119e6576024805460405163090ec10b60e31b81526001600160a01b0387811660048301528681169382019390935260448101859052911690634876085890606401600060405180830381600087803b1580156119cd57600080fd5b505af11580156119e1573d6000803e3d6000fd5b505050505b602454600160a81b900460ff1615611a0a57611a03848484611e98565b905061103f565b611a12611f7e565b15611a1f57611a1f611fd4565b611a276123dd565b15611a3457611a3461243f565b6040805180820182526014815273496e73756666696369656e742042616c616e636560601b6020808301919091526001600160a01b0387166000908152601f9091529190912054611a86918490611934565b6001600160a01b0385166000908152601f6020526040812091909155611aab8561247b565b611ab55782611ac0565b611ac08585856124ab565b6001600160a01b0385166000908152601f6020526040902054909150611ae69082611874565b6001600160a01b038086166000908152601f602090815260408083209490945591881681526023909152205460ff16611b8a57601b546001600160a01b038681166000818152601f602052604090819020549051630a5b654b60e11b8152600481019290925260248201529116906314b6ca9690604401600060405180830381600087803b158015611b7757600080fd5b505af1925050508015611b88575060015b505b6001600160a01b03841660009081526023602052604090205460ff16611c1b57601b546001600160a01b038581166000818152601f602052604090819020549051630a5b654b60e11b8152600481019290925260248201529116906314b6ca9690604401600060405180830381600087803b158015611c0857600080fd5b505af1925050508015611c19575060015b505b601b54601c546040516001624d3b8760e01b031981526001600160a01b039092169163ffb2c47991611c539160040190815260200190565b600060405180830381600087803b158015611c6d57600080fd5b505af1925050508015611c7e575060015b50836001600160a01b0316856001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051611cc491815260200190565b60405180910390a3506001949350505050565b600061103f8284612987565b600061103f8284612968565b600061103f8284612948565b6024805460ff60a81b1916600160a81b1790556040805160028082526060820183526000926020830190803683375050600654604080516315ab88c960e31b815290519394506001600160a01b039091169263ad5c464892506004808301926020929190829003018186803b158015611d7357600080fd5b505afa158015611d87573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611dab9190612597565b81600081518110611dcc57634e487b7160e01b600052603260045260246000fd5b60200260200101906001600160a01b031690816001600160a01b0316815250503081600181518110611e0e57634e487b7160e01b600052603260045260246000fd5b6001600160a01b03928316602091820292909201015260065460405163b6f9de9560e01b815291169063b6f9de95908590611e5490600090869088904290600401612827565b6000604051808303818588803b158015611e6d57600080fd5b505af1158015611e81573d6000803e3d6000fd5b50506024805460ff60a81b19169055505050505050565b6040805180820182526014815273496e73756666696369656e742042616c616e636560601b6020808301919091526001600160a01b0386166000908152601f90915291822054611ee9918490611934565b6001600160a01b038086166000908152601f60205260408082209390935590851681522054611f189083611874565b6001600160a01b038085166000818152601f602052604090819020939093559151908616907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef90611f6c9086815260200190565b60405180910390a35060019392505050565b6007546000906001600160a01b03163314801590611fa65750602454600160a81b900460ff16155b8015611fb45750601d5460ff165b80156110b2575050601e54306000908152601f6020526040902054101590565b6024805460ff60a81b1916600160a81b179055600f54601054600091611ff991610dae565b61200557600954612008565b60005b9050600080600d541115612039576120366002611328600d5461132886601e54611ce390919063ffffffff16565b90505b601e546000906120499083611cd7565b6040805160028082526060820183529293506000929091602083019080368337019050509050308160008151811061209157634e487b7160e01b600052603260045260246000fd5b6001600160a01b03928316602091820292909201810191909152600654604080516315ab88c960e31b81529051919093169263ad5c4648926004808301939192829003018186803b1580156120e557600080fd5b505afa1580156120f9573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061211d9190612597565b8160018151811061213e57634e487b7160e01b600052603260045260246000fd5b6001600160a01b03928316602091820292909201015260065460405163791ac94760e01b81524792919091169063791ac947906121889086906000908790309042906004016128f4565b600060405180830381600087803b1580156121a257600080fd5b505af11580156121b6573d6000803e3d6000fd5b5050505060006121cf8247611cd790919063ffffffff16565b905060006121ea6121e1886002611cef565b600d5490611cd7565b9050600081156122e25761220560026113288481878d611ce3565b9050600061222283611328600b5487611ce390919063ffffffff16565b9050600061223f84611328600c5488611ce390919063ffffffff16565b9050601b60009054906101000a90046001600160a01b03166001600160a01b031663d0e30db0836040518263ffffffff1660e01b81526004016000604051808303818588803b15801561229157600080fd5b505af1935050505080156122a3575060015b506008546040516001600160a01b039091169082156108fc029083906000818181858888f193505050501580156122de573d6000803e3d6000fd5b5050505b8615611e815760065460405163f305d71960e01b815230600482015260248101899052600060448201819052606482015261dead60848201524260a48201526001600160a01b039091169063f305d71990839060c4016060604051808303818588803b15801561235157600080fd5b505af1158015612365573d6000803e3d6000fd5b50505050506040513d601f19601f8201168201806040525081019061238a919061277d565b505060408051838152602081018a90527f424db2872186fa7e7afa7a5e902ed3b49a2ef19c2f5431e672462495dd6b450692500160405180910390a150506024805460ff60a81b19169055505050505050565b6007546000906001600160a01b031633148015906124055750602454600160a81b900460ff16155b8015612413575060155460ff165b801561242e575043601954601a5461242b9190612930565b11155b80156110b257505060185447101590565b61244d60185461dead611cfb565b43601a5560185460175461246091611874565b60178190556016541015612479576015805460ff191690555b565b6001600160a01b03811660009081526022602052604081205460ff1615801561115957506000600d541192915050565b600e5460075460009182916124dd9190611328906124d6906001600160a01b03898116911614611628565b8690611ce3565b306000908152601f60205260409020549091506124fa9082611874565b306000818152601f6020526040908190209290925590516001600160a01b038716907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9061254b9085815260200190565b60405180910390a361255d8382611cd7565b95945050505050565b8035801515811461257657600080fd5b919050565b60006020828403121561258c578081fd5b813561103f816129ef565b6000602082840312156125a8578081fd5b815161103f816129ef565b600080604083850312156125c5578081fd5b82356125d0816129ef565b915060208301356125e0816129ef565b809150509250929050565b6000806000606084860312156125ff578081fd5b833561260a816129ef565b9250602084013561261a816129ef565b929592945050506040919091013590565b6000806040838503121561263d578182fd5b8235612648816129ef565b915061265660208401612566565b90509250929050565b60008060408385031215612671578182fd5b823561267c816129ef565b946020939093013593505050565b60006020828403121561269b578081fd5b61103f82612566565b600080604083850312156126b6578182fd5b61267c83612566565b600080600080608085870312156126d4578081fd5b6126dd85612566565b966020860135965060408601359560600135945092505050565b600060208284031215612708578081fd5b5035919050565b60008060408385031215612721578182fd5b8235915061265660208401612566565b60008060408385031215612743578182fd5b50508035926020909101359150565b600080600060608486031215612766578283fd5b505081359360208301359350604090920135919050565b600080600060608486031215612791578283fd5b8351925060208401519150604084015190509250925092565b600080600080600060a086880312156127c1578283fd5b505083359560208501359550604085013594606081013594506080013592509050565b6000815180845260208085019450808401835b8381101561281c5781516001600160a01b0316875295820195908201906001016127f7565b509495945050505050565b84815260806020820152600061284060808301866127e4565b6001600160a01b03949094166040830152506060015292915050565b6000602080835283518082850152825b818110156128885785810183015185820160400152820161286c565b818111156128995783604083870101525b50601f01601f1916929092016040019392505050565b60208082526006908201526510a7aba722a960d11b604082015260600190565b6020808252600b908201526a085055551213d49256915160aa1b604082015260600190565b85815284602082015260a06040820152600061291360a08301866127e4565b6001600160a01b0394909416606083015250608001529392505050565b60008219821115612943576129436129d9565b500190565b60008261296357634e487b7160e01b81526012600452602481fd5b500490565b6000816000190483118215151615612982576129826129d9565b500290565b600082821015612999576129996129d9565b500390565b600181811c908216806129b257607f821691505b602082108114156129d357634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b6001600160a01b0381168114612a0457600080fd5b5056fea26469706673582212205d031d438195bc94087a2002a15d79b23c532d1eba849de306ecbaa1471c115664736f6c63430008040033

Deployed Bytecode Sourcemap

36351:18577:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37971:28;;;;;;;;;;;;;;;;;;;13708:25:1;;;13696:2;13681:18;37971:28:0;;;;;;;;50226:466;;;;;;;;;;-1:-1:-1;50226:466:0;;;;;:::i;:::-;;:::i;:::-;;51764:382;;;;;;;;;;-1:-1:-1;51764:382:0;;;;;:::i;:::-;;:::i;41714:94::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;42139:248::-;;;;;;;;;;-1:-1:-1;42139:248:0;;;;;:::i;:::-;;:::i;:::-;;;7826:14:1;;7819:22;7801:41;;7789:2;7774:18;42139:248:0;7756:92:1;37543:38:0;;;;;;;;;;;;;;;;54743:182;;;;;;;;;;-1:-1:-1;54743:182:0;;;;;:::i;:::-;;:::i;51652:104::-;;;;;;;;;;-1:-1:-1;51652:104:0;;;;;:::i;:::-;;:::i;37189:29::-;;;;;;;;;;;;;;;;41396:102;;;;;;;;;;-1:-1:-1;41478:12:0;;41396:102;;37493:43;;;;;;;;;;;;;;;;37159:23;;;;;;;;;;;;;;;;41249:102;;;;;;;;;;-1:-1:-1;41249:102:0;;;;;:::i;:::-;;:::i;53626:280::-;;;;;;;;;;-1:-1:-1;53626:280:0;;;;;:::i;:::-;;:::i;50700:449::-;;;;;;;;;;-1:-1:-1;50700:449:0;;;;;:::i;:::-;;:::i;42716:419::-;;;;;;;;;;-1:-1:-1;42716:419:0;;;;;:::i;:::-;;:::i;38329:25::-;;;;;;;;;;-1:-1:-1;38329:25:0;;;;-1:-1:-1;;;38329:25:0;;;;;;54386:142;;;;;;;;;;;;;:::i;53914:207::-;;;;;;;;;;-1:-1:-1;53914:207:0;;;;;:::i;:::-;;:::i;27792:103::-;;;;;;;;;;-1:-1:-1;27792:103:0;;;;;:::i;:::-;27847:4;27882:5;-1:-1:-1;;;;;27871:16:0;;;27882:5;;27871:16;;27792:103;41506:94;;;;;;;;;;-1:-1:-1;41506:94:0;;36715:1;14726:36:1;;14714:2;14699:18;41506:94:0;14681:87:1;37010:25:0;;;;;;;;;;;;;;;;37610:30;;;;;;;;;;-1:-1:-1;37610:30:0;;;;;;;;38184:43;;;;;;;;;;-1:-1:-1;38184:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;38291:31;;;;;;;;;;-1:-1:-1;38291:31:0;;;;-1:-1:-1;;;;;38291:31:0;;;;;;-1:-1:-1;;;;;5843:32:1;;;5825:51;;5813:2;5798:18;38291:31:0;5780:102:1;38234:48:0;;;;;;;;;;-1:-1:-1;38234:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;37729:32;;;;;;;;;;;;;;;;42395:117;;;;;;;;;;-1:-1:-1;42395:117:0;;;;;:::i;:::-;;:::i;37649:29::-;;;;;;;;;;;;;;;;37768:37;;;;;;;;;;;;;;;;37903:29;;;;;;;;;;;;;;;;37109:27;;;;;;;;;;;;;;;;37941:23;;;;;;;;;;-1:-1:-1;37941:23:0;;;;;;;;37685:37;;;;;;;;;;;;;;;;41816:119;;;;;;;;;;-1:-1:-1;41816:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;41909:18:0;41882:7;41909:18;;;:9;:18;;;;;;;41816:119;37058:28;;;;;;;;;;;;;;;;51539:105;;;;;;;;;;-1:-1:-1;51539:105:0;;;;;:::i;:::-;;:::i;37297:41::-;;;;;;;;;;;;;;;;37363;;;;;;;;;;;;;;;;37245:30;;;;;;;;;;;;;;;;41608:98;;;;;;;;;;;;;:::i;36960:27::-;;;;;;;;;;;;;;;;54129:249;;;;;;;;;;-1:-1:-1;54129:249:0;;;;;:::i;:::-;;:::i;36890:19::-;;;;;;;;;;-1:-1:-1;36890:19:0;;;;-1:-1:-1;;;;;36890:19:0;;;42520:188;;;;;;;;;;-1:-1:-1;42520:188:0;;;;;:::i;:::-;;:::i;49439:105::-;;;;;;;;;;;;;:::i;27465:94::-;;;;;;;;;;-1:-1:-1;27465:94:0;;;;;:::i;:::-;;:::i;37812:35::-;;;;;;;;;;;;;;;;37856:38;;;;;;;;;;-1:-1:-1;37856:38:0;;;;-1:-1:-1;;;;;37856:38:0;;;54536:199;;;;;;;;;;-1:-1:-1;54536:199:0;;;;;:::i;:::-;;:::i;45162:857::-;;;;;;;;;;;;;:::i;41943:188::-;;;;;;;;;;-1:-1:-1;41943:188:0;;;;;:::i;:::-;-1:-1:-1;;;;;42095:19:0;;;42063:7;42095:19;;;:11;:19;;;;;;;:28;;;;;;;;;;;;;41943:188;53276:342;;;;;;;;;;-1:-1:-1;53276:342:0;;;;;:::i;:::-;;:::i;52827:441::-;;;;;;;;;;-1:-1:-1;52827:441:0;;;;;:::i;:::-;;:::i;36916:35::-;;;;;;;;;;-1:-1:-1;36916:35:0;;;;-1:-1:-1;;;;;36916:35:0;;;37427:43;;;;;;;;;;;;;;;;38136:41;;;;;;;;;;-1:-1:-1;38136:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;27635:97;;;;;;;;;;-1:-1:-1;27635:97:0;;;;;:::i;:::-;;:::i;44980:174::-;;;;;;;;;;-1:-1:-1;44980:174:0;;;;;:::i;:::-;;:::i;28192:173::-;;;;;;;;;;-1:-1:-1;28192:173:0;;;;;:::i;:::-;;:::i;49090:341::-;;;;;;;;;;-1:-1:-1;49090:341:0;;;;;:::i;:::-;;:::i;51157:374::-;;;;;;;;;;-1:-1:-1;51157:374:0;;;;;:::i;:::-;;:::i;36818:26::-;;;;;;;;;;-1:-1:-1;36818:26:0;;;;-1:-1:-1;;;;;36818:26:0;;;36851:32;;;;;;;;;;-1:-1:-1;36851:32:0;;;;-1:-1:-1;;;;;36851:32:0;;;27966:107;;;;;;;;;;-1:-1:-1;27966:107:0;;;;;:::i;:::-;;:::i;36533:35::-;;;;;;;;;;;;36567:1;36533:35;;50226:466;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;;;;;;;;;50413:1:::1;50403:7;:11;50395:53;;;::::0;-1:-1:-1;;;50395:53:0;;10284:2:1;50395:53:0::1;::::0;::::1;10266:21:1::0;10323:2;10303:18;;;10296:30;10362:31;10342:18;;;10335:59;10411:18;;50395:53:0::1;10256:179:1::0;50395:53:0::1;50459:18;:29:::0;;-1:-1:-1;;50459:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;50499:14:::1;:21:::0;;;;-1:-1:-1;50531:22:0::1;:26:::0;50568:17:::1;:27:::0;50606:22:::1;:32:::0;50672:12:::1;50649:20;:35:::0;50226:466::o;51764:382::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;51978:160:::1;52001:13;52029:11;52055:14;52084:13;52112:15;51978:8;:160::i;:::-;51764:382:::0;;;;;:::o;41714:94::-;41762:13;41795:5;41788:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41714:94;:::o;42139:248::-;42275:10;42241:4;42263:23;;;:11;:23;;;;;;;-1:-1:-1;;;;;42263:32:0;;;;;;;;;;:41;;;42320:37;42241:4;;42263:32;;42320:37;;;;42298:6;13708:25:1;;13696:2;13681:18;;13663:76;42320:37:0;;;;;;;;-1:-1:-1;42375:4:0;42139:248;;;;:::o;54743:182::-;54850:4;54911:6;54879:29;54899:8;54879:19;:29::i;:::-;:38;;54743:182;-1:-1:-1;;;54743:182:0:o;51652:104::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51728:14:0;;;::::1;;::::0;;;:9:::1;:14;::::0;;;;:20;;-1:-1:-1;;51728:20:0::1;::::0;::::1;;::::0;;;::::1;::::0;;51652:104::o;41249:102::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;41320:13:::1;:23:::0;;;::::1;;-1:-1:-1::0;;;41320:23:0::1;-1:-1:-1::0;;;;41320:23:0;;::::1;::::0;;;::::1;::::0;;41249:102::o;53626:280::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;53770:1:::1;53755:12;:16;53747:63;;;::::0;-1:-1:-1;;;53747:63:0;;12593:2:1;53747:63:0::1;::::0;::::1;12575:21:1::0;12632:2;12612:18;;;12605:30;12671:34;12651:18;;;12644:62;-1:-1:-1;;;12722:18:1;;;12715:32;12764:19;;53747:63:0::1;12565:224:1::0;53747:63:0::1;53821:15;:25:::0;;;;53857:26:::1;:41:::0;53626:280::o;50700:449::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;50877:7:::1;50867:6;:17;;50859:62;;;::::0;-1:-1:-1;;;50859:62:0;;10642:2:1;50859:62:0::1;::::0;::::1;10624:21:1::0;;;10661:18;;;10654:30;10720:34;10700:18;;;10693:62;10772:18;;50859:62:0::1;10614:182:1::0;50859:62:0::1;50967:1;50940:23;50952:11:::0;50940:9;:23:::1;:::i;:::-;:28;;:55;;;;;50984:11;50972:9;:23;50940:55;50932:64;;;::::0;::::1;;51007:26;:38:::0;;;;51056:28:::1;:42:::0;51109:23:::1;:32:::0;50700:449::o;42716:419::-;42906:12;;-1:-1:-1;;;;;42871:19:0;;42850:4;42871:19;;;:11;:19;;;;;;;42891:10;42871:31;;;;;;;;42850:4;;42871:47;42867:201;;42969:87;;;;;;;;;;;-1:-1:-1;;;42969:87:0;;;;;;;;-1:-1:-1;;;;;42969:19:0;;-1:-1:-1;42969:19:0;;;;;;;;;42989:10;42969:31;;;;;;;;;;:87;;43023:6;;42969:53;:87::i;:::-;-1:-1:-1;;;;;42935:19:0;;;;;;:11;:19;;;;;;;42955:10;42935:31;;;;;;;:121;42867:201;43087:40;43101:6;43109:9;43120:6;43087:13;:40::i;:::-;43080:47;;42716:419;;;;;;:::o;54386:142::-;41909:9;:18;;;;36617:6;54439:7;41909:18;;;;;54466:12;;54439:7;;54466:54;;41909:18;;54466:33;;:12;:16;:33::i;:::-;:37;;:54::i;:::-;54459:61;;54386:142;:::o;53914:207::-;27847:4;27882:5;-1:-1:-1;;;;;27882:5:0;27171:10;27871:16;27155:38;;;;-1:-1:-1;;;27155:38:0;;;;;;;:::i;:::-;54048:11:::1;::::0;:65:::1;::::0;-1:-1:-1;;;54048:65:0;;::::1;::::0;::::1;14505:25:1::0;;;14546:18;;;14539:34;;;-1:-1:-1;;;;;54048:11:0;;::::1;::::0;:35:::1;::::0;14478:18:1;;54048:65:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;53914:207:::0;;:::o;42395:117::-;42450:4;42474:30;42482:7;42491:12;;42474:7;:30::i;:::-;42467:37;42395:117;-1:-1:-1;;42395:117:0:o;51539:105::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51610:19:0::1;;::::0;;;:11:::1;:19;::::0;;;;:26;;-1:-1:-1;;51610:26:0::1;51632:4;51610:26;::::0;;51539:105::o;41608:98::-;41658:13;41691:7;41684:14;;;;;:::i;54129:249::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;54234:7:::1;54227:3;:14;;:32;;;;;54252:7;54245:3;:14;;54227:32;54205:134;;;::::0;-1:-1:-1;;;54205:134:0;;11838:2:1;54205:134:0::1;::::0;::::1;11820:21:1::0;11877:2;11857:18;;;11850:30;11916:34;11896:18;;;11889:62;-1:-1:-1;;;11967:18:1;;;11960:50;12027:19;;54205:134:0::1;11810:242:1::0;54205:134:0::1;54350:14;:20:::0;54129:249::o;42520:188::-;42627:4;42656:44;42670:10;42682:9;42693:6;42656:13;:44::i;49439:105::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;49535:1:::1;49504:28;:32:::0;49439:105::o;27465:94::-;27847:4;27882:5;-1:-1:-1;;;;;27882:5:0;27171:10;27871:16;27155:38;;;;-1:-1:-1;;;27155:38:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27525:19:0::1;;::::0;;;27547:4:::1;27525:19;::::0;;;;;;;:26;;-1:-1:-1;;27525:26:0::1;::::0;;::::1;::::0;;27465:94::o;54536:199::-;54631:7;54663:64;54704:22;:20;:22::i;:::-;54686:4;;-1:-1:-1;;;;;54686:4:0;41882:7;41909:18;;;:9;:18;;;;;;54663:36;;54676:22;;54696:1;54676:19;:22::i;:::-;54663:8;;:12;:36::i;:::-;:40;;:64::i;45162:857::-;45211:7;45322:15;45249:57;45282:23;;45249:28;;:32;;:57;;;;:::i;:::-;:88;45231:755;;;45364:21;45388:114;45486:15;45388:75;45439:23;;45388:28;;:50;;:75;;;;:::i;:114::-;45364:138;;45517:19;45539:142;45672:8;;45539:110;45620:28;;45539:58;45570:26;;45539:8;;:30;;:58;;;;:::i;:142::-;45517:164;;45696:20;45719:105;45750:59;45785:23;;45750:30;45766:13;45750:11;:15;;:30;;;;:::i;:59::-;45719:8;;;:12;:105::i;:::-;45696:128;;45895:1;45878:14;;:18;;;;:::i;:::-;45863:12;:33;:111;;45962:12;45863:111;;;45937:1;45920:14;;:18;;;;:::i;:::-;45839:135;;;;;45162:857;:::o;45231:755::-;-1:-1:-1;46003:8:0;;;45162:857::o;53276:342::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;53413:8:::1;:45;;;;;53451:7;53436:12;;:22;;;;:::i;:::-;53425:7;:33;;53413:45;53391:152;;;::::0;-1:-1:-1;;;53391:152:0;;11003:2:1;53391:152:0::1;::::0;::::1;10985:21:1::0;11042:2;11022:18;;;11015:30;11081:34;11061:18;;;11054:62;11152:27;11132:18;;;11125:55;11197:19;;53391:152:0::1;10975:247:1::0;53391:152:0::1;53554:11;:22:::0;;-1:-1:-1;;53554:22:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;53587:13:::1;:23:::0;53276:342::o;52827:441::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;52984:20:::1;::::0;-1:-1:-1;;;;;52959:45:0;;::::1;52984:20:::0;::::1;52959:45;;52937:135;;;::::0;-1:-1:-1;;;52937:135:0;;11429:2:1;52937:135:0::1;::::0;::::1;11411:21:1::0;11468:2;11448:18;;;11441:30;11507:34;11487:18;;;11480:62;-1:-1:-1;;;11558:18:1;;;11551:38;11606:19;;52937:135:0::1;11401:230:1::0;52937:135:0::1;-1:-1:-1::0;;;;;53106:32:0;::::1;11732:20:::0;11780:8;53083:122:::1;;;::::0;-1:-1:-1;;;53083:122:0;;9878:2:1;53083:122:0::1;::::0;::::1;9860:21:1::0;9917:2;9897:18;;;9890:30;9956:34;9936:18;;;9929:62;-1:-1:-1;;;10007:18:1;;;10000:35;10052:19;;53083:122:0::1;9850:227:1::0;53083:122:0::1;53216:20;:44:::0;;-1:-1:-1;;;;;;53216:44:0::1;-1:-1:-1::0;;;;;53216:44:0;;;::::1;::::0;;;::::1;::::0;;52827:441::o;27635:97::-;27847:4;27882:5;-1:-1:-1;;;;;27882:5:0;27171:10;27871:16;27155:38;;;;-1:-1:-1;;;27155:38:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27697:19:0::1;27719:5;27697:19:::0;;;:14:::1;:19;::::0;;;;:27;;-1:-1:-1;;27697:27:0::1;::::0;;27635:97::o;44980:174::-;45036:7;45060;45056:65;;;45091:18;:16;:18::i;45056:65::-;-1:-1:-1;;45138:8:0;;;44980:174::o;28192:173::-;27847:4;27882:5;-1:-1:-1;;;;;27882:5:0;27171:10;27871:16;27155:38;;;;-1:-1:-1;;;27155:38:0;;;;;;;:::i;:::-;28268:5:::1;:11:::0;;-1:-1:-1;;;;;;28268:11:0::1;-1:-1:-1::0;;;;;28268:11:0;::::1;::::0;;::::1;::::0;;28290:19;;;-1:-1:-1;28290:19:0::1;::::0;;;;;;;;:26;;-1:-1:-1;;28290:26:0::1;::::0;;::::1;::::0;;;28332:25;;5825:51:1;;;28332:25:0::1;::::0;5798:18:1;28332:25:0::1;;;;;;;28192:173:::0;:::o;49090:341::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;49219:23:::1;49229:6;36617;49219:9;:23::i;:::-;49257:24;49253:171;;;49329:15;49298:28;:46:::0;49388:23:::1;::::0;49364:48:::1;::::0;13708:25:1;;;49364:48:0::1;::::0;13696:2:1;13681:18;49364:48:0::1;;;;;;;49253:171;49090:341:::0;;:::o;51157:374::-;27341:24;27354:10;27341:12;:24::i;:::-;27333:48;;;;-1:-1:-1;;;27333:48:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51277:23:0;::::1;51295:4;51277:23;::::0;::::1;::::0;:41:::1;;-1:-1:-1::0;51314:4:0::1;::::0;-1:-1:-1;;;;;51304:14:0;;::::1;51314:4:::0;::::1;51304:14;;51277:41;51269:50;;;::::0;::::1;;-1:-1:-1::0;;;;;51330:24:0;::::1;;::::0;;;:16:::1;:24;::::0;;;;:33;;-1:-1:-1;;51330:33:0::1;::::0;::::1;::::0;::::1;::::0;;;::::1;::::0;;;51374:150:::1;;51401:11;::::0;:31:::1;::::0;-1:-1:-1;;;51401:31:0;;-1:-1:-1;;;;;6683:32:1;;;51401:31:0::1;::::0;::::1;6665:51:1::0;51401:11:0::1;6732:18:1::0;;;6725:34;51401:11:0;;::::1;::::0;:20:::1;::::0;6638:18:1;;51401:31:0::1;6620:145:1::0;51374:150:0::1;51465:11;::::0;-1:-1:-1;;;;;51494:17:0;;::::1;51465:11;51494:17:::0;;;:9:::1;:17;::::0;;;;;;;51465:47;;-1:-1:-1;;;51465:47:0;;::::1;::::0;::::1;6665:51:1::0;;;;6732:18;;;6725:34;51465:11:0;::::1;::::0;:20:::1;::::0;6638:18:1;;51465:47:0::1;6620:145:1::0;27966:107:0;-1:-1:-1;;;;;28046:19:0;28022:4;28046:19;;;:14;:19;;;;;;;;;27966:107::o;11409:387::-;11732:20;11780:8;;;11409:387::o;2837:98::-;2895:7;2922:5;2926:1;2922;:5;:::i;52154:665::-;52360:12;:28;;;52399:10;:24;;;52434:13;:30;;;52475:12;:28;;;52525:93;52490:13;52525:50;52450:14;52525:50;52375:13;52412:11;52525:17;:30::i;:::-;:34;;:50::i;:93::-;52514:8;:104;52629:14;:32;;;52706:18;52723:1;52646:15;52706:18;:::i;:::-;52694:8;;:30;;52672:139;;;;-1:-1:-1;;;52672:139:0;;13336:2:1;52672:139:0;;;13318:21:1;13375:2;13355:18;;;13348:30;13414:34;13394:18;;;13387:62;13485:29;13465:18;;;13458:57;13532:19;;52672:139:0;13308: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;43143:1282::-;43290:13;;43269:4;;-1:-1:-1;;;43290:13:0;;;;43286:103;;;43320:11;;;:57;;-1:-1:-1;;;43320:57:0;;-1:-1:-1;;;;;6361:15:1;;;43320:57:0;;;6343:34:1;6413:15;;;6393:18;;;6386:43;;;;6445:18;;;6438:34;;;43320:11:0;;;:30;;6278:18:1;;43320:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43286:103;43405:6;;-1:-1:-1;;;43405:6:0;;;;43401:87;;;43435:41;43450:6;43458:9;43469:6;43435:14;:41::i;:::-;43428:48;;;;43401:87;43504:16;:14;:16::i;:::-;43500:59;;;43537:10;:8;:10::i;:::-;43573:19;:17;:19::i;:::-;43569:72;;;43609:20;:18;:20::i;:::-;43673:90;;;;;;;;;;;-1:-1:-1;;;43673:90:0;;;;;;;;-1:-1:-1;;;;;43673:17:0;;-1:-1:-1;43673:17:0;;;:9;:17;;;;;;;;:90;;43709:6;;43673:21;:90::i;:::-;-1:-1:-1;;;;;43653:17:0;;;;;;:9;:17;;;;;:110;;;;43801:21;43663:6;43801:13;:21::i;:::-;:93;;43888:6;43801:93;;;43838:34;43846:6;43854:9;43865:6;43838:7;:34::i;:::-;-1:-1:-1;;;;;43930:20:0;;;;;;:9;:20;;;;;;43776:118;;-1:-1:-1;43930:40:0;;43776:118;43930:24;:40::i;:::-;-1:-1:-1;;;;;43907:20:0;;;;;;;:9;:20;;;;;;;;:63;;;;43988:24;;;;;:16;:24;;;;;;;43983:120;;44033:11;;-1:-1:-1;;;;;44062:17:0;;;44033:11;44062:17;;;:9;:17;;;;;;;;44033:47;;-1:-1:-1;;;44033:47:0;;;;;6665:51:1;;;;6732:18;;;6725:34;44033:11:0;;;:20;;6638:18:1;;44033:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44029:63;;-1:-1:-1;;;;;44118:27:0;;;;;;:16;:27;;;;;;;;44113:159;;44183:11;;-1:-1:-1;;;;;44215:20:0;;;44183:11;44215:20;;;:9;:20;;;;;;;;44183:53;;-1:-1:-1;;;44183:53:0;;;;;6665:51:1;;;;6732:18;;;6725:34;44183:11:0;;;:20;;6638:18:1;;44183:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44162:99;;44288:11;;44308:14;;44288:35;;-1:-1:-1;;;;;;44288:35:0;;-1:-1:-1;;;;;44288:11:0;;;;:19;;:35;;;;13708:25:1;;;13696:2;13681:18;;13663:76;44288:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44284:51;44369:9;-1:-1:-1;;;;;44352:43:0;44361:6;-1:-1:-1;;;;;44352:43:0;;44380:14;44352:43;;;;13708:25:1;;13696:2;13681:18;;13663:76;44352:43:0;;;;;;;;-1:-1:-1;44413:4:0;;43143:1282;-1:-1:-1;;;;43143:1282: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;49887:331::-;38530:6;:13;;-1:-1:-1;;;;38530:13:0;-1:-1:-1;;;38530:13:0;;;49987:16:::1;::::0;;50001:1:::1;49987:16:::0;;;;;::::1;::::0;;-1:-1:-1;;49987:16:0::1;::::0;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;50024:6:0::1;::::0;:13:::1;::::0;;-1:-1:-1;;;50024:13:0;;;;49963:40;;-1:-1:-1;;;;;;50024:6:0;;::::1;::::0;:11:::1;::::0;-1:-1:-1;50024:13:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;:6;:13;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50014:4;50019:1;50014:7;;;;;;-1:-1:-1::0;;;50014:7:0::1;;;;;;;;;;;;;;:23;-1:-1:-1::0;;;;;50014:23:0::1;;;-1:-1:-1::0;;;;;50014:23:0::1;;;::::0;::::1;50066:4;50048;50053:1;50048:7;;;;;;-1:-1:-1::0;;;50048:7:0::1;;;;;;;;;-1:-1:-1::0;;;;;50048:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;50084:6:::1;::::0;:126:::1;::::0;-1:-1:-1;;;50084:126:0;;:6;::::1;::::0;:57:::1;::::0;50163:6;;50084:126:::1;::::0;:6:::1;::::0;50184:4;;50190:2;;50194:15:::1;::::0;50084:126:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;38566:6:0;:14;;-1:-1:-1;;;;38566:14:0;;;-1:-1:-1;;;;;;49887:331:0:o;44433:401::-;44597:90;;;;;;;;;;;-1:-1:-1;;;44597:90:0;;;;;;;;-1:-1:-1;;;;;44597:17:0;;44560:4;44597:17;;;:9;:17;;;;;;;:90;;44633:6;;44597:21;:90::i;:::-;-1:-1:-1;;;;;44577:17:0;;;;;;;:9;:17;;;;;;:110;;;;44721:20;;;;;;;:32;;44746:6;44721:24;:32::i;:::-;-1:-1:-1;;;;;44698:20:0;;;;;;;:9;:20;;;;;;;:55;;;;44769:35;;;;;;;;;;44797:6;13708:25:1;;13696:2;13681:18;;13663:76;44769:35:0;;;;;;;;-1:-1:-1;44822:4:0;44433:401;;;;;:::o;46465:222::-;46565:4;;46514;;-1:-1:-1;;;;;46565:4:0;46551:10;:18;;;;:42;;-1:-1:-1;46587:6:0;;-1:-1:-1;;;46587:6:0;;;;46586:7;46551:42;:70;;;;-1:-1:-1;46610:11:0;;;;46551:70;:128;;;;-1:-1:-1;;46666:13:0;;46656:4;46638:24;;;;:9;:24;;;;;;:41;;;46465:222::o;46695:2032::-;38530:6;:13;;-1:-1:-1;;;;38530:13:0;-1:-1:-1;;;38530:13:0;;;46804:15:::1;::::0;46834:26:::1;::::0;38530:13;;46774:97:::1;::::0;:15:::1;:97::i;:::-;:142;;46904:12;;46774:142;;;46887:1;46774:142;46744:172;;46927:23;46976:1:::0;46965:8:::1;;:12;46961:176;;;47012:113;47123:1;47012:88;47091:8;;47012:56;47048:19;47012:13;;:35;;:56;;;;:::i;:113::-;46994:131;;46961:176;47172:13;::::0;47149:20:::1;::::0;47172:34:::1;::::0;47190:15;47172:17:::1;:34::i;:::-;47243:16;::::0;;47257:1:::1;47243:16:::0;;;;;::::1;::::0;;47149:57;;-1:-1:-1;47219:21:0::1;::::0;47243:16;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;47243:16:0::1;47219:40;;47288:4;47270;47275:1;47270:7;;;;;;-1:-1:-1::0;;;47270:7:0::1;;;;;;;;;-1:-1:-1::0;;;;;47270:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;;:23;;;;47314:6:::1;::::0;:13:::1;::::0;;-1:-1:-1;;;47314:13:0;;;;:6;;;::::1;::::0;:11:::1;::::0;:13:::1;::::0;;::::1;::::0;47270:7;;47314:13;;;;;:6;:13;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47304:4;47309:1;47304:7;;;;;;-1:-1:-1::0;;;47304:7:0::1;;;;;;;;;-1:-1:-1::0;;;;;47304:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;47396:6:::1;::::0;:188:::1;::::0;-1:-1:-1;;;47396:188:0;;47362:21:::1;::::0;47396:6;;;::::1;::::0;:57:::1;::::0;:188:::1;::::0;47468:12;;47338:21:::1;::::0;47511:4;;47538::::1;::::0;47558:15:::1;::::0;47396:188:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;47597:17;47617:40;47643:13;47617:21;:25;;:40;;;;:::i;:::-;47597:60:::0;-1:-1:-1;47670:19:0::1;47692:40;47705:26;:19:::0;47729:1:::1;47705:23;:26::i;:::-;47692:8;::::0;;:12:::1;:40::i;:::-;47670:62:::0;-1:-1:-1;47745:26:0::1;47786:15:::0;;47782:579:::1;;47839:112;47949:1;47839:87;47914:11:::0;47839:87;:9;47871:19;47839:31:::1;:52::i;:112::-;47818:133;;47968:27;47998:77;48049:11;47998:28;48012:13;;47998:9;:13;;:28;;;;:::i;:77::-;47968:107;;48090:26;48119:76;48169:11;48119:27;48133:12;;48119:9;:13;;:27;;;;:::i;:76::-;48090:105;;48216:11;;;;;;;;;-1:-1:-1::0;;;;;48216:11:0::1;-1:-1:-1::0;;;;;48216:19:0::1;;48243;48216:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;48212:65:::0;48299:20:::1;::::0;48291:58:::1;::::0;-1:-1:-1;;;;;48299:20:0;;::::1;::::0;48291:58;::::1;;;::::0;48330:18;;48299:20:::1;48291:58:::0;48299:20;48291:58;48330:18;48299:20;48291:58;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;47782:579;;;48377:19:::0;;48373:347:::1;;48413:6;::::0;:227:::1;::::0;-1:-1:-1;;;48413:227:0;;48489:4:::1;48413:227;::::0;::::1;7390:34:1::0;7440:18;;;7433:34;;;48413:6:0::1;7483:18:1::0;;;7476:34;;;7526:18;;;7519:34;36617:6:0::1;7569:19:1::0;;;7562:44;48610:15:0::1;7622:19:1::0;;;7615:35;-1:-1:-1;;;;;48413:6:0;;::::1;::::0;:22:::1;::::0;48443:18;;7324:19:1;;48413:227:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;48660:48:0::1;::::0;;14505:25:1;;;14561:2;14546:18;;14539:34;;;48660:48:0::1;::::0;-1:-1:-1;14478:18:1;48660:48:0::1;;;;;;;-1:-1:-1::0;;38566:6:0;:14;;-1:-1:-1;;;;38566:14:0;;;-1:-1:-1;;;;;;46695:2032:0:o;48735:347::-;48838:4;;48787;;-1:-1:-1;;;;;48838:4:0;48824:10;:18;;;;:42;;-1:-1:-1;48860:6:0;;-1:-1:-1;;;48860:6:0;;;;48859:7;48824:42;:77;;;;-1:-1:-1;48883:18:0;;;;48824:77;:155;;;;;48967:12;48941:22;;48918:20;;:45;;;;:::i;:::-;:61;;48824:155;:250;;;;-1:-1:-1;;49057:17:0;;49032:21;:42;;;48735:347::o;49552:327::-;49602:34;49612:17;;36617:6;49602:9;:34::i;:::-;49670:12;49647:20;:35;49745:17;;49718:22;;:45;;:26;:45::i;:::-;49693:22;:70;;;49803:14;;-1:-1:-1;49774:98:0;;;49834:18;:26;;-1:-1:-1;;49834:26:0;;;49774:98;49552:327::o;44842:130::-;-1:-1:-1;;;;;44929:19:0;;44904:4;44929:19;;;:11;:19;;;;;;;;44928:20;:36;;;;;44963:1;44952:8;;:12;44921:43;44842:130;-1:-1:-1;;44842:130:0:o;46027:430::-;46246:14;;46221:4;;46146:7;;;;46186:85;;46246:14;46186:41;;46197:29;;-1:-1:-1;;;;;46209:16:0;;;46221:4;;46209:16;46197:11;:29::i;:::-;46186:6;;:10;:41::i;:85::-;46329:4;46311:24;;;;:9;:24;;;;;;46166:105;;-1:-1:-1;46311:39:0;;46166:105;46311:28;:39::i;:::-;46302:4;46284:24;;;;:9;:24;;;;;;;:66;;;;46366:42;;-1:-1:-1;;;;;46366:42:0;;;;;;;46398:9;13708:25:1;;13696:2;13681:18;;13663:76;46366:42:0;;;;;;;;46428:21;:6;46439:9;46428:10;:21::i;:::-;46421:28;46027:430;-1:-1:-1;;;;;46027: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;8553:510::-;8824:6;8813:9;8806:25;8867:3;8862:2;8851:9;8847:18;8840:31;8787:4;8888:57;8940:3;8929:9;8925:19;8917:6;8888:57;:::i;:::-;-1:-1:-1;;;;;8981:32:1;;;;8976:2;8961:18;;8954:60;-1:-1:-1;9045:2:1;9030:18;9023:34;8880:65;8796:267;-1:-1:-1;;8796:267:1:o;9068:603::-;9180:4;9209:2;9238;9227:9;9220:21;9270:6;9264:13;9313:6;9308:2;9297:9;9293:18;9286:34;9338:4;9351:140;9365:6;9362:1;9359:13;9351:140;;;9460:14;;;9456:23;;9450:30;9426:17;;;9445:2;9422:26;9415:66;9380:10;;9351:140;;;9509:6;9506:1;9503:13;9500:2;;;9579:4;9574:2;9565:6;9554:9;9550:22;9546:31;9539:45;9500:2;-1:-1:-1;9655:2:1;9634:15;-1:-1:-1;;9630:29:1;9615:45;;;;9662:2;9611:54;;9189:482;-1:-1:-1;;;9189:482:1:o;12057:329::-;12259:2;12241:21;;;12298:1;12278:18;;;12271:29;-1:-1:-1;;;12331:2:1;12316:18;;12309:36;12377:2;12362:18;;12231:155::o;12794:335::-;12996:2;12978:21;;;13035:2;13015:18;;;13008:30;-1:-1:-1;;;13069:2:1;13054:18;;13047:41;13120:2;13105:18;;12968:161::o;13744:582::-;14043:6;14032:9;14025:25;14086:6;14081:2;14070:9;14066:18;14059:34;14129:3;14124:2;14113:9;14109:18;14102:31;14006:4;14150:57;14202:3;14191:9;14187:19;14179:6;14150:57;:::i;:::-;-1:-1:-1;;;;;14243:32:1;;;;14238:2;14223:18;;14216:60;-1:-1:-1;14307:3:1;14292:19;14285:35;14142:65;14015:311;-1:-1:-1;;;14015:311:1:o;14773:128::-;14813:3;14844:1;14840:6;14837:1;14834:13;14831:2;;;14850:18;;:::i;:::-;-1:-1:-1;14886:9:1;;14821:80::o;14906:217::-;14946:1;14972;14962:2;;-1:-1:-1;;;14997:31:1;;15051:4;15048:1;15041:15;15079:4;15004:1;15069:15;14962:2;-1:-1:-1;15108:9:1;;14952:171::o;15128:168::-;15168:7;15234:1;15230;15226:6;15222:14;15219:1;15216:21;15211:1;15204:9;15197:17;15193:45;15190:2;;;15241:18;;:::i;:::-;-1:-1:-1;15281:9:1;;15180:116::o;15301:125::-;15341:4;15369:1;15366;15363:8;15360:2;;;15374:18;;:::i;:::-;-1:-1:-1;15411:9:1;;15350:76::o;15431:380::-;15510:1;15506:12;;;;15553;;;15574:2;;15628:4;15620:6;15616:17;15606:27;;15574:2;15681;15673:6;15670:14;15650:18;15647:38;15644:2;;;15727:10;15722:3;15718:20;15715:1;15708:31;15762:4;15759:1;15752:15;15790:4;15787:1;15780:15;15644:2;;15486:325;;;:::o;15816:127::-;15877:10;15872:3;15868:20;15865:1;15858:31;15908:4;15905:1;15898:15;15932:4;15929:1;15922:15;15948:131;-1:-1:-1;;;;;16023:31:1;;16013:42;;16003:2;;16069:1;16066;16059:12;16003:2;15993:86;:::o

Swarm Source

ipfs://ed920347aec7c9fad5e52a9669a33e6c7bbb8ebc5f39973bbfe2ac8bf61ed277

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

OVERVIEW

SP is an open-source cryptocurrency using distributed information technology. The core technology of SP, which adds stability to this, is to reward SHIB without a wallet connection to a stacking or pool.

Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Txn Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.