ETH Price: $3,294.13 (-1.08%)

Contract

0xe2512A2f19F0388aD3D7A5263eaA82AcD564827b
 

Overview

ETH Balance

0.08940404 ETH

Eth Value

$294.51 (@ $3,294.13/ETH)

More Info

Private Name Tags

TokenTracker

Shido (SHIDO) (@$0.001)
Transaction Hash
Method
Block
From
To
Transfer214636972024-12-23 7:28:1151 secs ago1734938891IN
Shido: SHIDO Token
0 ETH0.000337974.9285983
Transfer214636752024-12-23 7:23:355 mins ago1734938615IN
Shido: SHIDO Token
0 ETH0.000304445.16055362
Transfer214636702024-12-23 7:22:356 mins ago1734938555IN
Shido: SHIDO Token
0 ETH0.000300834.38614315
Approve214628732024-12-23 4:42:352 hrs ago1734928955IN
Shido: SHIDO Token
0 ETH0.000217054.69277246
Transfer214624732024-12-23 3:21:594 hrs ago1734924119IN
Shido: SHIDO Token
0 ETH0.0009057315.47790338
Transfer214624452024-12-23 3:16:114 hrs ago1734923771IN
Shido: SHIDO Token
0 ETH0.000734978.57867175
Transfer214624302024-12-23 3:13:114 hrs ago1734923591IN
Shido: SHIDO Token
0 ETH0.000485057.07206761
Approve214621652024-12-23 2:19:475 hrs ago1734920387IN
Shido: SHIDO Token
0 ETH0.000308136.61915031
Transfer214620052024-12-23 1:47:355 hrs ago1734918455IN
Shido: SHIDO Token
0 ETH0.000288054.19984477
Transfer214619752024-12-23 1:41:355 hrs ago1734918095IN
Shido: SHIDO Token
0 ETH0.000361495.27057576
Transfer214608822024-12-22 22:00:599 hrs ago1734904859IN
Shido: SHIDO Token
0 ETH0.0007206112.31190738
Transfer214608532024-12-22 21:55:119 hrs ago1734904511IN
Shido: SHIDO Token
0 ETH0.000476495.56083933
Approve214608312024-12-22 21:50:479 hrs ago1734904247IN
Shido: SHIDO Token
0 ETH0.000299056.41585092
Transfer214605822024-12-22 21:00:3510 hrs ago1734901235IN
Shido: SHIDO Token
0 ETH0.000490327.15015425
Transfer214605572024-12-22 20:55:2310 hrs ago1734900923IN
Shido: SHIDO Token
0 ETH0.000424537.19611523
Approve214604632024-12-22 20:36:2310 hrs ago1734899783IN
Shido: SHIDO Token
0 ETH0.000313776.7700721
Approve214602152024-12-22 19:46:3511 hrs ago1734896795IN
Shido: SHIDO Token
0 ETH0.000360697.79649879
Transfer214601992024-12-22 19:43:2311 hrs ago1734896603IN
Shido: SHIDO Token
0 ETH0.000762489.43491289
Approve214601982024-12-22 19:43:1111 hrs ago1734896591IN
Shido: SHIDO Token
0 ETH0.000412868.86897214
Approve214600772024-12-22 19:18:3512 hrs ago1734895115IN
Shido: SHIDO Token
0 ETH0.000290966.24237708
Approve214599612024-12-22 18:55:2312 hrs ago1734893723IN
Shido: SHIDO Token
0 ETH0.000385268.26540158
Transfer214598992024-12-22 18:42:5912 hrs ago1734892979IN
Shido: SHIDO Token
0 ETH0.000554238.69374547
Transfer214597972024-12-22 18:22:3513 hrs ago1734891755IN
Shido: SHIDO Token
0 ETH0.000481677.02649594
Approve214590842024-12-22 15:58:5915 hrs ago1734883139IN
Shido: SHIDO Token
0 ETH0.000448879.63000325
Transfer214589972024-12-22 15:41:3515 hrs ago1734882095IN
Shido: SHIDO Token
0 ETH0.0006337.38944499
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Transaction Hash Block
From
To
214589432024-12-22 15:30:4715 hrs ago1734881447
Shido: SHIDO Token
0.42406247 ETH
214589432024-12-22 15:30:4715 hrs ago1734881447
Shido: SHIDO Token
0.42406247 ETH
214589422024-12-22 15:30:3515 hrs ago1734881435
Shido: SHIDO Token
0.42406247 ETH
214589422024-12-22 15:30:3515 hrs ago1734881435
Shido: SHIDO Token
0.42406247 ETH
214457282024-12-20 19:09:592 days ago1734721799
Shido: SHIDO Token
0.44010561 ETH
214457282024-12-20 19:09:592 days ago1734721799
Shido: SHIDO Token
0.44010561 ETH
214339072024-12-19 3:33:234 days ago1734579203
Shido: SHIDO Token
0.42384764 ETH
214339072024-12-19 3:33:234 days ago1734579203
Shido: SHIDO Token
0.42384764 ETH
214089832024-12-15 16:02:477 days ago1734278567
Shido: SHIDO Token
0.49827072 ETH
214089832024-12-15 16:02:477 days ago1734278567
Shido: SHIDO Token
0.49827072 ETH
214089822024-12-15 16:02:357 days ago1734278555
Shido: SHIDO Token
0.49827072 ETH
214089822024-12-15 16:02:357 days ago1734278555
Shido: SHIDO Token
0.49827072 ETH
213923742024-12-13 8:23:599 days ago1734078239
Shido: SHIDO Token
0.52604655 ETH
213923742024-12-13 8:23:599 days ago1734078239
Shido: SHIDO Token
0.52604655 ETH
213809402024-12-11 18:05:3511 days ago1733940335
Shido: SHIDO Token
0.58808339 ETH
213809402024-12-11 18:05:3511 days ago1733940335
Shido: SHIDO Token
0.58808339 ETH
213809392024-12-11 18:05:2311 days ago1733940323
Shido: SHIDO Token
0.58808339 ETH
213809392024-12-11 18:05:2311 days ago1733940323
Shido: SHIDO Token
0.58808339 ETH
213578942024-12-08 12:52:5914 days ago1733662379
Shido: SHIDO Token
0.53491348 ETH
213578942024-12-08 12:52:5914 days ago1733662379
Shido: SHIDO Token
0.53491348 ETH
213437972024-12-06 13:37:2316 days ago1733492243
Shido: SHIDO Token
0.49408954 ETH
213437972024-12-06 13:37:2316 days ago1733492243
Shido: SHIDO Token
0.49408954 ETH
213329712024-12-05 1:19:3518 days ago1733361575
Shido: SHIDO Token
0.51050367 ETH
213329712024-12-05 1:19:3518 days ago1733361575
Shido: SHIDO Token
0.51050367 ETH
213317812024-12-04 21:19:5918 days ago1733347199
Shido: SHIDO Token
0.50961522 ETH
View All Internal Transactions
Loading...
Loading

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

Contract Name:
StandardToken

Compiler Version
v0.8.19+commit.7dd6d404

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2024-03-01
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.1;

library Address {
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }
    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");
    }
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }
    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

pragma solidity ^0.8.0;

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }
    function name() public view virtual override returns (string memory) {
        return _name;
    }
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

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

        _afterTokenTransfer(account, address(0), amount);
    }
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor() {
        _transferOwnership(_msgSender());
    }
    modifier onlyOwner() {
        _checkOwner();
        _;
    }
    function owner() public view virtual returns (address) {
        return _owner;
    }
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

interface IERC20Permit {
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
    function nonces(address owner) external view returns (uint256);
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

library SafeERC20 {
    using Address for address;
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

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;
}
interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

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;
}
pragma solidity 0.8.19;

interface IUniswapV2Caller {
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        address router,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        uint256 deadline
    ) external;
}
interface IFee {
    function payFee(
        uint256 _tokenType,
        address creator,
        bool isAntibot,
        address referrer
    ) external payable;
}
contract StandardToken is ERC20, Ownable {
    using SafeERC20 for IERC20;
    struct Args {
        string name;
        string symbol;
        uint8 decimals;
        uint256 totalSupply;
        uint256 maxWallet;
        uint256 maxTransactionAmount;
        address marketingWallet;
        address baseTokenForMarket;
        address mainRouter;
        bool isMarketingFeeBaseToken;
        uint24 sellLiquidityFee;
        uint24 buyLiquidityFee;
        uint24 sellMarketingFee;
        uint24 buyMarketingFee;
        address feeContract;
        address uniswapV2Caller;
    }
    IUniswapV2Caller public uniswapV2Caller;

    uint256 private constant MAX = ~uint256(0);

    uint8 private _decimals;
    ///////////////////////////////////////////////////////////////////////////
    address public baseTokenForMarket;
    bool public isBaseTokenWETH;
    bool private inSwapAndLiquify;
    uint24 public sellLiquidityFee;
    uint24 public buyLiquidityFee;

    uint24 public sellMarketingFee;
    uint24 public buyMarketingFee;

    address public marketingWallet;
    bool public isMarketingFeeBaseToken;

    uint256 public minAmountToTakeFee;
    uint256 public maxWallet;
    uint256 public maxTransactionAmount;

    address public mainRouter;
    address public mainPair;


    mapping(address => bool) public isExcludedFromMaxTransactionAmount;
    mapping(address => bool) public isExcludedFromFee;
    mapping(address => bool) public automatedMarketMakerPairs;

    uint256 private _liquidityFeeTokens;
    uint256 private _marketingFeeTokens;
    event UpdateLiquidityFee(
        uint24 newSellLiquidityFee,
        uint24 newBuyLiquidityFee,
        uint24 oldSellLiquidityFee,
        uint24 oldBuyLiquidityFee
    );
    event UpdateMarketingFee(
        uint24 newSellMarketingFee,
        uint24 newBuyMarketingFee,
        uint24 oldSellMarketingFee,
        uint24 oldBuyMarketingFee
    );
    event UpdateMarketingWallet(
        address indexed newMarketingWallet,
        bool newIsMarketingFeeBaseToken,
        address indexed oldMarketingWallet,
        bool oldIsMarketingFeeBaseToken
    );
    event ExcludedFromMaxTransactionAmount(address indexed account, bool isExcluded);
    event UpdateMinAmountToTakeFee(uint256 newMinAmountToTakeFee, uint256 oldMinAmountToTakeFee);
    event SetAutomatedMarketMakerPair(address indexed pair, bool value);
    event ExcludedFromFee(address indexed account, bool isEx);
    event SwapAndLiquify(
        uint256 tokensForLiquidity,
        uint256 baseTokenForLiquidity
    );
    event MarketingFeeTaken(
        uint256 marketingFeeTokens,
        uint256 marketingFeeBaseTokenSwapped
    );
    event MainRouterUpdated(
        address mainRouter, address mainPair, address baseTokenForMarket
    );
    event UpdateMaxWallet(uint256 newMaxWallet, uint256 oldMaxWallet);
    event UpdateMaxTransactionAmount(uint256 newMaxTransactionAmount, uint256 oldMaxTransactionAmount);
    ///////////////////////////////////////////////////////////////////////////////
 

    constructor(
        Args memory args,
        address[] memory autoApproveAddressList,
        address referrer
    ) ERC20(args.name, args.symbol) payable {
        IFee(args.feeContract).payFee{value: msg.value}(1, _msgSender(), false, referrer);   
        _decimals = args.decimals;
        _mint(msg.sender, args.totalSupply);
        uniswapV2Caller = IUniswapV2Caller(args.uniswapV2Caller);
        baseTokenForMarket=args.baseTokenForMarket;
        require(args.marketingWallet!=address(0), "marketing wallet can not be 0");
        require(args.mainRouter!=address(0), "Router address can not be 0");
        require(args.sellLiquidityFee+args.sellMarketingFee<=200000, "sell fee <= 20%");
        require(args.buyLiquidityFee+args.buyMarketingFee<=200000, "buy fee <= 20%");

        marketingWallet=args.marketingWallet;
        isMarketingFeeBaseToken=args.isMarketingFeeBaseToken;
        emit UpdateMarketingWallet(
            marketingWallet,
            isMarketingFeeBaseToken,
            address(0),
            false
        );
        mainRouter=args.mainRouter;
        if(baseTokenForMarket != IUniswapV2Router02(mainRouter).WETH()){            
            IERC20(baseTokenForMarket).safeApprove(mainRouter, MAX);            
        }else{
            isBaseTokenWETH=true;
        }
       
        
        _approve(address(this), address(uniswapV2Caller), MAX);
        _approve(address(this), mainRouter, MAX);
        for(uint256 i=0;i<autoApproveAddressList.length;i++){
            _approve(_msgSender(), autoApproveAddressList[i], MAX);
            isExcludedFromFee[autoApproveAddressList[i]] = true;
            isExcludedFromMaxTransactionAmount[autoApproveAddressList[i]]=true;
        }
        
        emit MainRouterUpdated(mainRouter, mainPair, baseTokenForMarket);
        mainPair = IUniswapV2Factory(IUniswapV2Router02(mainRouter).factory()).createPair(
            address(this),
            baseTokenForMarket
        );
 
        
        require(args.maxTransactionAmount>=args.totalSupply / 10000, "maxTransactionAmount >= total supply / 10000");
        require(args.maxWallet>=args.totalSupply / 10000, "maxWallet >= total supply / 10000");
        maxWallet=args.maxWallet;
        emit UpdateMaxWallet(maxWallet, 0);
        maxTransactionAmount=args.maxTransactionAmount;
        emit UpdateMaxTransactionAmount(maxTransactionAmount, 0);
        
        sellLiquidityFee=args.sellLiquidityFee;
        buyLiquidityFee=args.buyLiquidityFee;
        emit UpdateLiquidityFee(sellLiquidityFee, buyLiquidityFee, 0, 0);        
        sellMarketingFee=args.sellMarketingFee;
        buyMarketingFee=args.buyMarketingFee;
        emit UpdateMarketingFee(
            sellMarketingFee,
            buyMarketingFee,
            0,
            0
        );
        minAmountToTakeFee=args.totalSupply/10000;
        emit UpdateMinAmountToTakeFee(minAmountToTakeFee, 0);
        isExcludedFromFee[address(this)]=true;
        isExcludedFromFee[marketingWallet]=true;
        isExcludedFromFee[_msgSender()]=true;
        isExcludedFromFee[address(0xdead)] = true;
        isExcludedFromMaxTransactionAmount[address(0xdead)]=true;
        isExcludedFromMaxTransactionAmount[address(this)]=true;
        isExcludedFromMaxTransactionAmount[marketingWallet]=true;
        isExcludedFromMaxTransactionAmount[_msgSender()]=true;
        _setAutomatedMarketMakerPair(mainPair, true);
    }

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

    function updateMainPair(
        address _mainRouter,
        address _baseTokenForMarket
    ) external onlyOwner {
        baseTokenForMarket = _baseTokenForMarket;
        if(mainRouter != _mainRouter){
            _approve(address(this), _mainRouter, MAX);
            mainRouter = _mainRouter;
        } 
        mainPair = IUniswapV2Factory(IUniswapV2Router02(mainRouter).factory()).createPair(
            address(this),
            baseTokenForMarket
        );
        if(baseTokenForMarket != IUniswapV2Router02(mainRouter).WETH()){            
            IERC20(baseTokenForMarket).safeApprove(mainRouter, MAX);
            isBaseTokenWETH=false;            
        }else{
            isBaseTokenWETH=true;
        }
     
        emit MainRouterUpdated(mainRouter, mainPair, baseTokenForMarket);
        _setAutomatedMarketMakerPair(mainPair, true);
    }


    /////////////////////////////////////////////////////////////////////////////////
    modifier lockTheSwap() {
        inSwapAndLiquify = true;
        _;
        inSwapAndLiquify = false;
    }

    function updateLiquidityFee(
        uint24 _sellLiquidityFee,
        uint24 _buyLiquidityFee
    ) external onlyOwner {
        require(
            _sellLiquidityFee + sellMarketingFee <= 200000,
            "sell fee <= 20%"
        );
        require(_buyLiquidityFee + buyMarketingFee <= 200000, "buy fee <= 20%");
        emit UpdateLiquidityFee(
            _sellLiquidityFee,
            _buyLiquidityFee,
            sellLiquidityFee,
            buyLiquidityFee
        );
        sellLiquidityFee = _sellLiquidityFee;
        buyLiquidityFee = _buyLiquidityFee;           
    }

    function updateMaxWallet(uint256 _maxWallet) external onlyOwner {
        require(_maxWallet>=totalSupply() / 10000, "maxWallet >= total supply / 10000");
        emit UpdateMaxWallet(_maxWallet, maxWallet);
        maxWallet = _maxWallet;
    }

    function updateMaxTransactionAmount(uint256 _maxTransactionAmount)
        external
        onlyOwner
    {
        require(_maxTransactionAmount>=totalSupply() / 10000, "maxTransactionAmount >= total supply / 10000");
        emit UpdateMaxTransactionAmount(_maxTransactionAmount, maxTransactionAmount);
        maxTransactionAmount = _maxTransactionAmount;
    }

    function updateMarketingFee(
        uint24 _sellMarketingFee,
        uint24 _buyMarketingFee
    ) external onlyOwner {
        require(
            _sellMarketingFee + sellLiquidityFee <= 200000,
            "sell fee <= 20%"
        );
        require(_buyMarketingFee + buyLiquidityFee <= 200000, "buy fee <= 20%");
        emit UpdateMarketingFee(
            _sellMarketingFee,
            _buyMarketingFee,
            sellMarketingFee,
            buyMarketingFee
        );
        sellMarketingFee = _sellMarketingFee;
        buyMarketingFee = _buyMarketingFee;  
    }

    function updateMarketingWallet(
        address _marketingWallet,
        bool _isMarketingFeeBaseToken
    ) external onlyOwner {
        require(_marketingWallet != address(0), "marketing wallet can't be 0");
        emit UpdateMarketingWallet(_marketingWallet, _isMarketingFeeBaseToken,
            marketingWallet, isMarketingFeeBaseToken);
        marketingWallet = _marketingWallet;
        isMarketingFeeBaseToken = _isMarketingFeeBaseToken;
        isExcludedFromFee[_marketingWallet] = true;
        isExcludedFromMaxTransactionAmount[_marketingWallet] = true;
    }

    function updateMinAmountToTakeFee(uint256 _minAmountToTakeFee)
        external
        onlyOwner
    {
        require(_minAmountToTakeFee > 0, "minAmountToTakeFee > 0");
        emit UpdateMinAmountToTakeFee(_minAmountToTakeFee, minAmountToTakeFee);
        minAmountToTakeFee = _minAmountToTakeFee;     
    }

    function setAutomatedMarketMakerPair(address pair, bool value)
        public
        onlyOwner
    {
        require(
            automatedMarketMakerPairs[pair] != value,
            "Automated market maker pair is already set to that value"
        );
        _setAutomatedMarketMakerPair(pair, value);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {        
        automatedMarketMakerPairs[pair] = value;
        isExcludedFromMaxTransactionAmount[pair] = value;
        emit SetAutomatedMarketMakerPair(pair, value);
    }

    function excludeFromFee(address account, bool isEx) external onlyOwner {
        require(isExcludedFromFee[account] != isEx, "already");
        isExcludedFromFee[account] = isEx;
        emit ExcludedFromFee(account, isEx);
    }

    function excludeFromMaxTransactionAmount(address account, bool isEx)
        external
        onlyOwner
    {
        require(isExcludedFromMaxTransactionAmount[account]!=isEx, "already");
        isExcludedFromMaxTransactionAmount[account] = isEx;
        emit ExcludedFromMaxTransactionAmount(account, isEx);
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        uint256 contractTokenBalance = balanceOf(address(this));
        
        uint256 totalTokensTaken = _liquidityFeeTokens + _marketingFeeTokens;
        bool overMinimumTokenBalance = totalTokensTaken >=
            minAmountToTakeFee && totalTokensTaken <= contractTokenBalance;
        // Take Fee
        if (
            !inSwapAndLiquify &&
            balanceOf(mainPair) > 0 &&
            overMinimumTokenBalance &&
            automatedMarketMakerPairs[to]
        ) {
            takeFee();
        }

        uint256 _liquidityFee;
        uint256 _marketingFee;
        // If any account belongs to isExcludedFromFee account then remove the fee

        if (
            !inSwapAndLiquify &&
            !isExcludedFromFee[from] &&
            !isExcludedFromFee[to]
        ) {
            // Buy
            if (automatedMarketMakerPairs[from]) {
                _liquidityFee = amount * buyLiquidityFee / 1000000;
                _marketingFee = amount * buyMarketingFee / 1000000;
            }
            // Sell
            else if (automatedMarketMakerPairs[to]) {
                _liquidityFee = amount * sellLiquidityFee / 1000000;
                _marketingFee = amount * sellMarketingFee / 1000000;
            }
            uint256 _feeTotal = _liquidityFee + _marketingFee;
            if (_feeTotal > 0) super._transfer(from, address(this), _feeTotal);
            amount = amount - _liquidityFee - _marketingFee;
            _liquidityFeeTokens = _liquidityFeeTokens + _liquidityFee;
            _marketingFeeTokens = _marketingFeeTokens + _marketingFee;
        }
        super._transfer(from, to, amount);
        if (!inSwapAndLiquify) {
            if (!isExcludedFromMaxTransactionAmount[from]) {
                require(
                    amount < maxTransactionAmount,
                    "ERC20: exceeds transfer limit"
                );
            }
            if (!isExcludedFromMaxTransactionAmount[to]) {
                require(
                    balanceOf(to) < maxWallet,
                    "ERC20: exceeds max wallet limit"
                );
            }
        }
    }

    function takeFee() private lockTheSwap {

        // Halve the amount of liquidity tokens
        uint256 tokensForLiquidity = _liquidityFeeTokens / 2;
        uint256 initialBaseTokenBalance = isBaseTokenWETH ? address(this).balance
            : IERC20(baseTokenForMarket).balanceOf(address(this));        
         
        uint256 baseTokenForLiquidity;
        if (isMarketingFeeBaseToken) {
            uint256 tokensForSwap=tokensForLiquidity+_marketingFeeTokens;
            if(tokensForSwap>0)
                swapTokensForBaseToken(tokensForSwap);
            uint256 baseTokenBalance = isBaseTokenWETH ? address(this).balance - initialBaseTokenBalance
                : IERC20(baseTokenForMarket).balanceOf(address(this)) - initialBaseTokenBalance;
            uint256 baseTokenAmountForMarketing = (baseTokenBalance *
                _marketingFeeTokens) / tokensForSwap;
            baseTokenForLiquidity = baseTokenBalance - baseTokenAmountForMarketing;
            if(baseTokenAmountForMarketing>0){
                if(isBaseTokenWETH){                
                    (bool success, )=address(marketingWallet).call{value: baseTokenAmountForMarketing}("");
                    if(success){
                        emit MarketingFeeTaken(0, baseTokenAmountForMarketing);
                    }
                }else{
                    IERC20(baseTokenForMarket).safeTransfer(
                        marketingWallet,
                        baseTokenAmountForMarketing
                    );
                    emit MarketingFeeTaken(0, baseTokenAmountForMarketing);
                }                
            }            
        } else {
            if(tokensForLiquidity>0)
                swapTokensForBaseToken(tokensForLiquidity);
            baseTokenForLiquidity = isBaseTokenWETH ? address(this).balance - initialBaseTokenBalance
                : IERC20(baseTokenForMarket).balanceOf(address(this)) - initialBaseTokenBalance;
            if(_marketingFeeTokens>0){
                _transfer(address(this), marketingWallet, _marketingFeeTokens);
                emit MarketingFeeTaken(_marketingFeeTokens, 0);                
            }            
        }

        if (tokensForLiquidity > 0 && baseTokenForLiquidity > 0) {
            addLiquidity(tokensForLiquidity, baseTokenForLiquidity);
            emit SwapAndLiquify(tokensForLiquidity, baseTokenForLiquidity);
        }
        _marketingFeeTokens = 0;
        _liquidityFeeTokens = 0;    
        if(balanceOf(address(this))>0){
            if(owner()!=address(0)){
                _transfer(address(this), owner(), balanceOf(address(this)));  
            }else{
                _transfer(address(this), address(0xdead), balanceOf(address(this)));  
            }
        } 
    }

    function swapTokensForBaseToken(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = baseTokenForMarket;     
        if (isBaseTokenWETH){
            IUniswapV2Router02(mainRouter).swapExactTokensForETHSupportingFeeOnTransferTokens(
                tokenAmount,
                0, // accept any amount of BaseToken
                path,
                address(this),
                block.timestamp
            );
        }else{
            uniswapV2Caller.swapExactTokensForTokensSupportingFeeOnTransferTokens(
                    address(mainRouter),
                    tokenAmount,
                    0, // accept any amount of BaseToken
                    path,
                    block.timestamp
                );
        }
        
    }

    function addLiquidity(uint256 tokenAmount, uint256 baseTokenAmount)
        private
    {
        if (isBaseTokenWETH) 
            IUniswapV2Router02(mainRouter).addLiquidityETH{value: baseTokenAmount}(
                address(this),
                tokenAmount,
                0, // slippage is unavoidable
                0, // slippage is unavoidable
                address(0xdead),
                block.timestamp
            );
        else{
            IUniswapV2Router02(mainRouter).addLiquidity(
                address(this),
                baseTokenForMarket,
                tokenAmount,
                baseTokenAmount,
                0,
                0,
                address(0xdead),
                block.timestamp
            );
        }  
    }

    function withdrawETH() external onlyOwner {
        (bool success, )=address(owner()).call{value: address(this).balance}("");
        require(success, "Failed in withdrawal");
    }
    function withdrawToken(address token) external onlyOwner{
        require(address(this) != token, "Not allowed");
        IERC20(token).safeTransfer(owner(), IERC20(token).balanceOf(address(this)));
    }
    receive() external payable {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"maxWallet","type":"uint256"},{"internalType":"uint256","name":"maxTransactionAmount","type":"uint256"},{"internalType":"address","name":"marketingWallet","type":"address"},{"internalType":"address","name":"baseTokenForMarket","type":"address"},{"internalType":"address","name":"mainRouter","type":"address"},{"internalType":"bool","name":"isMarketingFeeBaseToken","type":"bool"},{"internalType":"uint24","name":"sellLiquidityFee","type":"uint24"},{"internalType":"uint24","name":"buyLiquidityFee","type":"uint24"},{"internalType":"uint24","name":"sellMarketingFee","type":"uint24"},{"internalType":"uint24","name":"buyMarketingFee","type":"uint24"},{"internalType":"address","name":"feeContract","type":"address"},{"internalType":"address","name":"uniswapV2Caller","type":"address"}],"internalType":"struct StandardToken.Args","name":"args","type":"tuple"},{"internalType":"address[]","name":"autoApproveAddressList","type":"address[]"},{"internalType":"address","name":"referrer","type":"address"}],"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":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isEx","type":"bool"}],"name":"ExcludedFromFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludedFromMaxTransactionAmount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"mainRouter","type":"address"},{"indexed":false,"internalType":"address","name":"mainPair","type":"address"},{"indexed":false,"internalType":"address","name":"baseTokenForMarket","type":"address"}],"name":"MainRouterUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"marketingFeeTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"marketingFeeBaseTokenSwapped","type":"uint256"}],"name":"MarketingFeeTaken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensForLiquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"baseTokenForLiquidity","type":"uint256"}],"name":"SwapAndLiquify","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint24","name":"newSellLiquidityFee","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"newBuyLiquidityFee","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"oldSellLiquidityFee","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"oldBuyLiquidityFee","type":"uint24"}],"name":"UpdateLiquidityFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint24","name":"newSellMarketingFee","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"newBuyMarketingFee","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"oldSellMarketingFee","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"oldBuyMarketingFee","type":"uint24"}],"name":"UpdateMarketingFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newMarketingWallet","type":"address"},{"indexed":false,"internalType":"bool","name":"newIsMarketingFeeBaseToken","type":"bool"},{"indexed":true,"internalType":"address","name":"oldMarketingWallet","type":"address"},{"indexed":false,"internalType":"bool","name":"oldIsMarketingFeeBaseToken","type":"bool"}],"name":"UpdateMarketingWallet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxTransactionAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldMaxTransactionAmount","type":"uint256"}],"name":"UpdateMaxTransactionAmount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxWallet","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldMaxWallet","type":"uint256"}],"name":"UpdateMaxWallet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMinAmountToTakeFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldMinAmountToTakeFee","type":"uint256"}],"name":"UpdateMinAmountToTakeFee","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","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":[],"name":"baseTokenForMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyLiquidityFee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyMarketingFee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"isEx","type":"bool"}],"name":"excludeFromFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"isEx","type":"bool"}],"name":"excludeFromMaxTransactionAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isBaseTokenWETH","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromMaxTransactionAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isMarketingFeeBaseToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mainPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mainRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTransactionAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minAmountToTakeFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellLiquidityFee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellMarketingFee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Caller","outputs":[{"internalType":"contract IUniswapV2Caller","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint24","name":"_sellLiquidityFee","type":"uint24"},{"internalType":"uint24","name":"_buyLiquidityFee","type":"uint24"}],"name":"updateLiquidityFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_mainRouter","type":"address"},{"internalType":"address","name":"_baseTokenForMarket","type":"address"}],"name":"updateMainPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint24","name":"_sellMarketingFee","type":"uint24"},{"internalType":"uint24","name":"_buyMarketingFee","type":"uint24"}],"name":"updateMarketingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_marketingWallet","type":"address"},{"internalType":"bool","name":"_isMarketingFeeBaseToken","type":"bool"}],"name":"updateMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxTransactionAmount","type":"uint256"}],"name":"updateMaxTransactionAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxWallet","type":"uint256"}],"name":"updateMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minAmountToTakeFee","type":"uint256"}],"name":"updateMinAmountToTakeFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Deployed Bytecode

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

Deployed Bytecode Sourcemap

36338:19208:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6027:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6945:201;;;;;;;;;;-1:-1:-1;6945:201:0;;;;;:::i;:::-;;:::i;:::-;;;1291:14:1;;1284:22;1266:41;;1254:2;1239:18;6945:201:0;1126:187:1;6342:108:0;;;;;;;;;;-1:-1:-1;6430:12:0;;6342:108;;;1464:25:1;;;1452:2;1437:18;6342:108:0;1318:177:1;44816:249:0;;;;;;;;;;-1:-1:-1;44816:249:0;;;;;:::i;:::-;;:::i;:::-;;7152:261;;;;;;;;;;-1:-1:-1;7152:261:0;;;;;:::i;:::-;;:::i;47810:323::-;;;;;;;;;;-1:-1:-1;47810:323:0;;;;;:::i;:::-;;:::i;42993:92::-;;;;;;;;;;-1:-1:-1;43068:9:0;;-1:-1:-1;;;43068:9:0;;;;42993:92;;2828:4:1;2816:17;;;2798:36;;2786:2;2771:18;42993:92:0;2656:184:1;7419:238:0;;;;;;;;;;-1:-1:-1;7419:238:0;;;;;:::i;:::-;;:::i;46058:586::-;;;;;;;;;;-1:-1:-1;46058:586:0;;;;;:::i;:::-;;:::i;37160:33::-;;;;;;;;;;-1:-1:-1;37160:33:0;;;;-1:-1:-1;;;;;37160:33:0;;;;;;-1:-1:-1;;;;;3009:32:1;;;2991:51;;2979:2;2964:18;37160:33:0;2845:203:1;37755:49:0;;;;;;;;;;-1:-1:-1;37755:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;37457:35;;;;;;;;;;-1:-1:-1;37457:35:0;;;;-1:-1:-1;;;37457:35:0;;;;;;43093:891;;;;;;;;;;-1:-1:-1;43093:891:0;;;;;:::i;:::-;;:::i;6456:127::-;;;;;;;;;;-1:-1:-1;6456:127:0;;;;;:::i;:::-;;:::i;11661:103::-;;;;;;;;;;;;;:::i;46652:319::-;;;;;;;;;;-1:-1:-1;46652:319:0;;;;;:::i;:::-;;:::i;37420:30::-;;;;;;;;;;-1:-1:-1;37420:30:0;;;;;;;-1:-1:-1;;;;;37420:30:0;;;37382:29;;;;;;;;;;-1:-1:-1;37382:29:0;;;;;;;;;;;3872:8:1;3860:21;;;3842:40;;3830:2;3815:18;37382:29:0;3698:190:1;36950:39:0;;;;;;;;;;-1:-1:-1;36950:39:0;;;;-1:-1:-1;;;;;36950:39:0;;;37648:23;;;;;;;;;;-1:-1:-1;37648:23:0;;;;-1:-1:-1;;;;;37648:23:0;;;55301:207;;;;;;;;;;-1:-1:-1;55301:207:0;;;;;:::i;:::-;;:::i;11430:87::-;;;;;;;;;;-1:-1:-1;11503:6:0;;-1:-1:-1;;;;;11503:6:0;11430:87;;37345:30;;;;;;;;;;-1:-1:-1;37345:30:0;;;;-1:-1:-1;;;37345:30:0;;;;;;6133:104;;;;;;;;;;;;;:::i;46979:320::-;;;;;;;;;;-1:-1:-1;46979:320:0;;;;;:::i;:::-;;:::i;7663:436::-;;;;;;;;;;-1:-1:-1;7663:436:0;;;;;:::i;:::-;;:::i;6589:193::-;;;;;;;;;;-1:-1:-1;6589:193:0;;;;;:::i;:::-;;:::i;45073:371::-;;;;;;;;;;-1:-1:-1;45073:371:0;;;;;:::i;:::-;;:::i;37811:57::-;;;;;;;;;;-1:-1:-1;37811:57:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;37572:35;;;;;;;;;;;;;;;;37616:25;;;;;;;;;;-1:-1:-1;37616:25:0;;;;-1:-1:-1;;;;;37616:25:0;;;44201:607;;;;;;;;;;-1:-1:-1;44201:607:0;;;;;:::i;:::-;;:::i;6788:151::-;;;;;;;;;;-1:-1:-1;6788:151:0;;;;;:::i;:::-;;:::i;47568:234::-;;;;;;;;;;-1:-1:-1;47568:234:0;;;;;:::i;:::-;;:::i;55111:184::-;;;;;;;;;;;;;:::i;37682:66::-;;;;;;;;;;-1:-1:-1;37682:66:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;45452:598;;;;;;;;;;-1:-1:-1;45452:598:0;;;;;:::i;:::-;;:::i;37307:29::-;;;;;;;;;;-1:-1:-1;37307:29:0;;;;-1:-1:-1;;;37307:29:0;;;;;;37200:27;;;;;;;;;;-1:-1:-1;37200:27:0;;;;-1:-1:-1;;;37200:27:0;;;;;;11770:201;;;;;;;;;;-1:-1:-1;11770:201:0;;;;;:::i;:::-;;:::i;37270:30::-;;;;;;;;;;-1:-1:-1;37270:30:0;;;;-1:-1:-1;;;37270:30:0;;;;;;37541:24;;;;;;;;;;;;;;;;37501:33;;;;;;;;;;;;;;;;6027:100;6081:13;6114:5;6107:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6027:100;:::o;6945:201::-;7028:4;5491:10;7084:32;5491:10;7100:7;7109:6;7084:8;:32::i;:::-;7134:4;7127:11;;;6945:201;;;;;:::o;44816:249::-;11391:13;:11;:13::i;:::-;44927:5:::1;44911:13;6430:12:::0;;;6342:108;44911:13:::1;:21;;;;:::i;:::-;44899:10;:33;;44891:79;;;::::0;-1:-1:-1;;;44891:79:0;;5494:2:1;44891:79:0::1;::::0;::::1;5476:21:1::0;5533:2;5513:18;;;5506:30;5572:34;5552:18;;;5545:62;-1:-1:-1;;;5623:18:1;;;5616:31;5664:19;;44891:79:0::1;;;;;;;;;45014:9;::::0;44986:38:::1;::::0;;5868:25:1;;;5924:2;5909:18;;5902:34;;;;44986:38:0::1;::::0;5841:18:1;44986:38:0::1;;;;;;;45035:9;:22:::0;44816:249::o;7152:261::-;7249:4;5491:10;7307:38;7323:4;5491:10;7338:6;7307:15;:38::i;:::-;7356:27;7366:4;7372:2;7376:6;7356:9;:27::i;:::-;-1:-1:-1;7401:4:0;;7152:261;-1:-1:-1;;;;7152:261:0:o;47810:323::-;11391:13;:11;:13::i;:::-;-1:-1:-1;;;;;47940:43:0;::::1;;::::0;;;:34:::1;:43;::::0;;;;;:49;::::1;;:43;::::0;;::::1;:49;;::::0;47932:69:::1;;;::::0;-1:-1:-1;;;47932:69:0;;6149:2:1;47932:69:0::1;::::0;::::1;6131:21:1::0;6188:1;6168:18;;;6161:29;-1:-1:-1;;;6206:18:1;;;6199:37;6253:18;;47932:69:0::1;5947:330:1::0;47932:69:0::1;-1:-1:-1::0;;;;;48012:43:0;::::1;;::::0;;;:34:::1;:43;::::0;;;;;;;;:50;;-1:-1:-1;;48012:50:0::1;::::0;::::1;;::::0;;::::1;::::0;;;48078:47;;1266:41:1;;;48078:47:0::1;::::0;1239:18:1;48078:47:0::1;;;;;;;;47810:323:::0;;:::o;7419:238::-;7507:4;5491:10;7563:64;5491:10;7579:7;7616:10;7588:25;5491:10;7579:7;7588:9;:25::i;:::-;:38;;;;:::i;:::-;7563:8;:64::i;46058:586::-;11391:13;:11;:13::i;:::-;-1:-1:-1;;;;;46209:30:0;::::1;46201:70;;;::::0;-1:-1:-1;;;46201:70:0;;6614:2:1;46201:70:0::1;::::0;::::1;6596:21:1::0;6653:2;6633:18;;;6626:30;6692:29;6672:18;;;6665:57;6739:18;;46201:70:0::1;6412:351:1::0;46201:70:0::1;46366:15;::::0;46287:120:::1;::::0;;6955:14:1;;6948:22;6930:41;;46383:23:0::1;-1:-1:-1::0;;;46383:23:0;::::1;;7014:14:1::0;7007:22;7002:2;6987:18;;6980:50;-1:-1:-1;;;;;46366:15:0;;;::::1;::::0;::::1;::::0;46287:120;::::1;::::0;::::1;::::0;6903:18:1;46287:120:0::1;;;;;;;46418:15;:34:::0;;-1:-1:-1;;;;;;46463:50:0;46418:34;-1:-1:-1;;;;;46418:34:0;;;::::1;::::0;;::::1;-1:-1:-1::0;;;;46463:50:0;;-1:-1:-1;;;46463:50:0;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;46524:35:0;;;:17:::1;:35;::::0;;;;;;;:42;;-1:-1:-1;;46524:42:0;;::::1;-1:-1:-1::0;46524:42:0;;::::1;::::0;;;46577:34:::1;:52:::0;;;;;:59;;;;::::1;::::0;;::::1;::::0;;46058:586::o;43093:891::-;11391:13;:11;:13::i;:::-;43222:18:::1;:40:::0;;-1:-1:-1;;;;;;43222:40:0::1;-1:-1:-1::0;;;;;43222:40:0;;::::1;::::0;;;::::1;::::0;;;43276:10:::1;::::0;:25;;::::1;:10:::0;::::1;:25;43273:136;;43317:41;43334:4;43341:11:::0;-1:-1:-1;;43317:8:0::1;:41::i;:::-;43373:10;:24:::0;;-1:-1:-1;;;;;;43373:24:0::1;-1:-1:-1::0;;;;;43373:24:0;::::1;;::::0;;43273:136:::1;43468:10;;;;;;;;;-1:-1:-1::0;;;;;43468:10:0::1;-1:-1:-1::0;;;;;43449:38:0::1;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43544:18;::::0;43431:142:::1;::::0;-1:-1:-1;;;43431:142:0;;43524:4:::1;43431:142;::::0;::::1;7509:34:1::0;-1:-1:-1;;;;;43544:18:0;;::::1;7559::1::0;;;7552:43;43431:70:0;::::1;::::0;::::1;::::0;7444:18:1;;43431:142:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43420:8;:153:::0;;-1:-1:-1;;;;;;43420:153:0::1;-1:-1:-1::0;;;;;43420:153:0;;::::1;;::::0;;43628:10:::1;::::0;43609:37:::1;::::0;;-1:-1:-1;;;43609:37:0;;;;43628:10;;;::::1;::::0;43609:35:::1;::::0;:37:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;43628:10;43609:37:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43587:18;::::0;-1:-1:-1;;;;;43587:18:0;;::::1;:59:::0;::::1;;43584:256;;43713:10;::::0;43681:18:::1;::::0;43674:55:::1;::::0;-1:-1:-1;;;;;43681:18:0;;::::1;::::0;43713:10:::1;-1:-1:-1::0;;43674:38:0::1;:55::i;:::-;43744:15;:21:::0;;-1:-1:-1;;;;43744:21:0::1;::::0;;43584:256:::1;;;43808:15;:20:::0;;-1:-1:-1;;;;43808:20:0::1;-1:-1:-1::0;;;43808:20:0::1;::::0;;43584:256:::1;43880:10;::::0;43892:8:::1;::::0;43902:18:::1;::::0;43862:59:::1;::::0;;-1:-1:-1;;;;;43880:10:0;;::::1;7846:34:1::0;;43892:8:0;;::::1;7911:2:1::0;7896:18;;7889:43;43902:18:0;::::1;7948::1::0;;;7941:43;43862:59:0;;::::1;::::0;;;;7796:2:1;43862:59:0;;::::1;43961:8;::::0;43932:44:::1;::::0;-1:-1:-1;;;;;43961:8:0::1;::::0;43932:28:::1;:44::i;:::-;43093:891:::0;;:::o;6456:127::-;-1:-1:-1;;;;;6557:18:0;6530:7;6557:18;;;;;;;;;;;;6456:127::o;11661:103::-;11391:13;:11;:13::i;:::-;11726:30:::1;11753:1;11726:18;:30::i;:::-;11661:103::o:0;46652:319::-;11391:13;:11;:13::i;:::-;46798:1:::1;46776:19;:23;46768:58;;;::::0;-1:-1:-1;;;46768:58:0;;8197:2:1;46768:58:0::1;::::0;::::1;8179:21:1::0;8236:2;8216:18;;;8209:30;-1:-1:-1;;;8255:18:1;;;8248:52;8317:18;;46768:58:0::1;7995:346:1::0;46768:58:0::1;46888:18;::::0;46842:65:::1;::::0;;5868:25:1;;;5924:2;5909:18;;5902:34;;;;46842:65:0::1;::::0;5841:18:1;46842:65:0::1;;;;;;;46918:18;:40:::0;46652:319::o;55301:207::-;11391:13;:11;:13::i;:::-;-1:-1:-1;;;;;55376:22:0;::::1;55384:4;55376:22:::0;55368:46:::1;;;::::0;-1:-1:-1;;;55368:46:0;;8548:2:1;55368:46:0::1;::::0;::::1;8530:21:1::0;8587:2;8567:18;;;8560:30;-1:-1:-1;;;8606:18:1;;;8599:41;8657:18;;55368:46:0::1;8346:335:1::0;55368:46:0::1;55425:75;55452:7;11503:6:::0;;-1:-1:-1;;;;;11503:6:0;;11430:87;55452:7:::1;55461:38;::::0;-1:-1:-1;;;55461:38:0;;55493:4:::1;55461:38;::::0;::::1;2991:51:1::0;-1:-1:-1;;;;;55461:23:0;::::1;::::0;::::1;::::0;2964:18:1;;55461:38:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;55425:26:0;::::1;::::0;:75;:26:::1;:75::i;:::-;55301:207:::0;:::o;6133:104::-;6189:13;6222:7;6215:14;;;;;:::i;46979:320::-;11391:13;:11;:13::i;:::-;-1:-1:-1;;;;;47115:31:0;::::1;;::::0;;;:25:::1;:31;::::0;;;;;:40;::::1;;:31;::::0;;::::1;:40;;::::0;47093:146:::1;;;::::0;-1:-1:-1;;;47093:146:0;;9077:2:1;47093:146:0::1;::::0;::::1;9059:21:1::0;9116:2;9096:18;;;9089:30;9155:34;9135:18;;;9128:62;9226:26;9206:18;;;9199:54;9270:19;;47093:146:0::1;8875:420:1::0;47093:146:0::1;47250:41;47279:4;47285:5;47250:28;:41::i;7663:436::-:0;7756:4;5491:10;7756:4;7839:25;5491:10;7856:7;7839:9;:25::i;:::-;7812:52;;7903:15;7883:16;:35;;7875:85;;;;-1:-1:-1;;;7875:85:0;;9502:2:1;7875:85:0;;;9484:21:1;9541:2;9521:18;;;9514:30;9580:34;9560:18;;;9553:62;-1:-1:-1;;;9631:18:1;;;9624:35;9676:19;;7875:85:0;9300:401:1;7875:85:0;7996:60;8005:5;8012:7;8040:15;8021:16;:34;7996:8;:60::i;6589:193::-;6668:4;5491:10;6724:28;5491:10;6741:2;6745:6;6724:9;:28::i;45073:371::-;11391:13;:11;:13::i;:::-;45240:5:::1;45224:13;6430:12:::0;;;6342:108;45224:13:::1;:21;;;;:::i;:::-;45201;:44;;45193:101;;;::::0;-1:-1:-1;;;45193:101:0;;9908:2:1;45193:101:0::1;::::0;::::1;9890:21:1::0;9947:2;9927:18;;;9920:30;9986:34;9966:18;;;9959:62;-1:-1:-1;;;10037:18:1;;;10030:42;10089:19;;45193:101:0::1;9706:408:1::0;45193:101:0::1;45360:20;::::0;45310:71:::1;::::0;;5868:25:1;;;5924:2;5909:18;;5902:34;;;;45310:71:0::1;::::0;5841:18:1;45310:71:0::1;;;;;;;45392:20;:44:::0;45073:371::o;44201:607::-;11391:13;:11;:13::i;:::-;44377:16:::1;::::0;44397:6:::1;::::0;44357:36:::1;::::0;-1:-1:-1;;;44377:16:0;::::1;;;44357:17:::0;:36:::1;:::i;:::-;:46;;;;44335:111;;;::::0;-1:-1:-1;;;44335:111:0;;10496:2:1;44335:111:0::1;::::0;::::1;10478:21:1::0;10535:2;10515:18;;;10508:30;-1:-1:-1;;;10554:18:1;;;10547:45;10609:18;;44335:111:0::1;10294:339:1::0;44335:111:0::1;44484:15;::::0;44503:6:::1;::::0;44465:34:::1;::::0;44484:15:::1;;44465:16:::0;:34:::1;:::i;:::-;:44;;;;44457:71;;;::::0;-1:-1:-1;;;44457:71:0;;10840:2:1;44457:71:0::1;::::0;::::1;10822:21:1::0;10879:2;10859:18;;;10852:30;-1:-1:-1;;;10898:18:1;;;10891:44;10952:18;;44457:71:0::1;10638:338:1::0;44457:71:0::1;44640:16;::::0;44544:153:::1;::::0;;44640:16:::1;11249:15:1::0;;;11231:34;;11301:15;;;11296:2;11281:18;;11274:43;-1:-1:-1;;;44640:16:0;::::1;::::0;::::1;11333:18:1::0;;;11326:43;-1:-1:-1;;;44671:15:0;;::::1;::::0;;::::1;11400:2:1::0;11385:18;;11378:43;44544:153:0;::::1;::::0;;;;11191:3:1;44544:153:0;;::::1;44708:16;:36:::0;;-1:-1:-1;;;;44755:34:0;-1:-1:-1;;;44708:36:0::1;::::0;;::::1;;-1:-1:-1::0;;;;44755:34:0;;-1:-1:-1;;;44755:34:0;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;44201:607::o;6788:151::-;-1:-1:-1;;;;;6904:18:0;;;6877:7;6904:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;6788:151::o;47568:234::-;11391:13;:11;:13::i;:::-;-1:-1:-1;;;;;47658:26:0;::::1;;::::0;;;:17:::1;:26;::::0;;;;;:34;::::1;;:26;::::0;;::::1;:34;;::::0;47650:54:::1;;;::::0;-1:-1:-1;;;47650:54:0;;6149:2:1;47650:54:0::1;::::0;::::1;6131:21:1::0;6188:1;6168:18;;;6161:29;-1:-1:-1;;;6206:18:1;;;6199:37;6253:18;;47650:54:0::1;5947:330:1::0;47650:54:0::1;-1:-1:-1::0;;;;;47715:26:0;::::1;;::::0;;;:17:::1;:26;::::0;;;;;;;;:33;;-1:-1:-1;;47715:33:0::1;::::0;::::1;;::::0;;::::1;::::0;;;47764:30;;1266:41:1;;;47764:30:0::1;::::0;1239:18:1;47764:30:0::1;1126:187:1::0;55111:184:0;11391:13;:11;:13::i;:::-;55165:12:::1;55189:7;11503:6:::0;;-1:-1:-1;;;;;11503:6:0;;11430:87;55189:7:::1;-1:-1:-1::0;;;;;55181:21:0::1;55210;55181:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55164:72;;;55255:7;55247:40;;;::::0;-1:-1:-1;;;55247:40:0;;11844:2:1;55247:40:0::1;::::0;::::1;11826:21:1::0;11883:2;11863:18;;;11856:30;-1:-1:-1;;;11902:18:1;;;11895:50;11962:18;;55247:40:0::1;11642:344:1::0;45452:598:0;11391:13;:11;:13::i;:::-;45628:16:::1;::::0;45648:6:::1;::::0;45608:36:::1;::::0;-1:-1:-1;;;45628:16:0;::::1;;;45608:17:::0;:36:::1;:::i;:::-;:46;;;;45586:111;;;::::0;-1:-1:-1;;;45586:111:0;;10496:2:1;45586:111:0::1;::::0;::::1;10478:21:1::0;10535:2;10515:18;;;10508:30;-1:-1:-1;;;10554:18:1;;;10547:45;10609:18;;45586:111:0::1;10294:339:1::0;45586:111:0::1;45735:15;::::0;45754:6:::1;::::0;45716:34:::1;::::0;-1:-1:-1;;;45735:15:0;::::1;;;45716:16:::0;:34:::1;:::i;:::-;:44;;;;45708:71;;;::::0;-1:-1:-1;;;45708:71:0;;10840:2:1;45708:71:0::1;::::0;::::1;10822:21:1::0;10879:2;10859:18;;;10852:30;-1:-1:-1;;;10898:18:1;;;10891:44;10952:18;;45708:71:0::1;10638:338:1::0;45708:71:0::1;45891:16;::::0;45922:15:::1;::::0;45795:153:::1;::::0;;45891:16:::1;11249:15:1::0;;;11231:34;;11301:15;;;11296:2;11281:18;;11274:43;-1:-1:-1;;;45891:16:0;;::::1;::::0;::::1;11333:18:1::0;;;11326:43;45922:15:0;;;::::1;11400:2:1::0;11385:18;;11378:43;45795:153:0;::::1;::::0;;;;11191:3:1;45795:153:0;;::::1;45959:16;:36:::0;;-1:-1:-1;;;;45959:36:0::1;-1:-1:-1::0;;;45959:36:0::1;::::0;;::::1;;;::::0;;46006:15:::1;:34:::0;;-1:-1:-1;;46006:34:0::1;::::0;;;::::1;;::::0;;45452:598::o;11770:201::-;11391:13;:11;:13::i;:::-;-1:-1:-1;;;;;11859:22:0;::::1;11851:73;;;::::0;-1:-1:-1;;;11851:73:0;;12193:2:1;11851:73:0::1;::::0;::::1;12175:21:1::0;12232:2;12212:18;;;12205:30;12271:34;12251:18;;;12244:62;-1:-1:-1;;;12322:18:1;;;12315:36;12368:19;;11851:73:0::1;11991:402:1::0;11851:73:0::1;11935:28;11954:8;11935:18;:28::i;10152:346::-:0;-1:-1:-1;;;;;10254:19:0;;10246:68;;;;-1:-1:-1;;;10246:68:0;;12600:2:1;10246:68:0;;;12582:21:1;12639:2;12619:18;;;12612:30;12678:34;12658:18;;;12651:62;-1:-1:-1;;;12729:18:1;;;12722:34;12773:19;;10246:68:0;12398:400:1;10246:68:0;-1:-1:-1;;;;;10333:21:0;;10325:68;;;;-1:-1:-1;;;10325:68:0;;13005:2:1;10325:68:0;;;12987:21:1;13044:2;13024:18;;;13017:30;13083:34;13063:18;;;13056:62;-1:-1:-1;;;13134:18:1;;;13127:32;13176:19;;10325:68:0;12803:398:1;10325:68:0;-1:-1:-1;;;;;10406:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10458:32;;1464:25:1;;;10458:32:0;;1437:18:1;10458:32:0;;;;;;;10152:346;;;:::o;11523:132::-;11503:6;;-1:-1:-1;;;;;11503:6:0;5491:10;11587:23;11579:68;;;;-1:-1:-1;;;11579:68:0;;13408:2:1;11579:68:0;;;13390:21:1;;;13427:18;;;13420:30;13486:34;13466:18;;;13459:62;13538:18;;11579:68:0;13206:356:1;10504:419:0;10605:24;10632:25;10642:5;10649:7;10632:9;:25::i;:::-;10605:52;;-1:-1:-1;;10672:16:0;:37;10668:248;;10754:6;10734:16;:26;;10726:68;;;;-1:-1:-1;;;10726:68:0;;13769:2:1;10726:68:0;;;13751:21:1;13808:2;13788:18;;;13781:30;13847:31;13827:18;;;13820:59;13896:18;;10726:68:0;13567:353:1;10726:68:0;10838:51;10847:5;10854:7;10882:6;10863:16;:25;10838:8;:51::i;:::-;10594:329;10504:419;;;:::o;48141:2456::-;-1:-1:-1;;;;;48273:18:0;;48265:68;;;;-1:-1:-1;;;48265:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;48352:16:0;;48344:64;;;;-1:-1:-1;;;48344:64:0;;;;;;;:::i;:::-;48419:28;48450:24;48468:4;48450:9;:24::i;:::-;48419:55;;48495:24;48544:19;;48522;;:41;;;;:::i;:::-;48495:68;;48574:28;48638:18;;48605:16;:51;;:95;;;;;48680:20;48660:16;:40;;48605:95;48751:16;;48574:126;;-1:-1:-1;;;;48751:16:0;;;;48750:17;:57;;;;-1:-1:-1;48794:8:0;;48806:1;;48784:19;;-1:-1:-1;;;;;48794:8:0;48784:9;:19::i;:::-;:23;48750:57;:97;;;;;48824:23;48750:97;:143;;;;-1:-1:-1;;;;;;48864:29:0;;;;;;:25;:29;;;;;;;;48750:143;48732:209;;;48920:9;:7;:9::i;:::-;49122:16;;48953:21;;;;-1:-1:-1;;;49122:16:0;;;;49121:17;:58;;;;-1:-1:-1;;;;;;49156:23:0;;;;;;:17;:23;;;;;;;;49155:24;49121:58;:97;;;;-1:-1:-1;;;;;;49197:21:0;;;;;;:17;:21;;;;;;;;49196:22;49121:97;49103:946;;;-1:-1:-1;;;;;49269:31:0;;;;;;:25;:31;;;;;;;;49265:422;;;49346:15;;49364:7;;49337:24;;-1:-1:-1;;;49346:15:0;;;;49337:6;:24;:::i;:::-;:34;;;;:::i;:::-;49415:15;;49321:50;;-1:-1:-1;49433:7:0;;49406:24;;49415:15;;49406:6;:24;:::i;:::-;:34;;;;:::i;:::-;49390:50;;49265:422;;;-1:-1:-1;;;;;49500:29:0;;;;;;:25;:29;;;;;;;;49496:191;;;49575:16;;49594:7;;49566:25;;-1:-1:-1;;;49575:16:0;;;;49566:6;:25;:::i;:::-;:35;;;;:::i;:::-;49645:16;;49550:51;;-1:-1:-1;49664:7:0;;49636:25;;-1:-1:-1;;;49645:16:0;;;;49636:6;:25;:::i;:::-;:35;;;;:::i;:::-;49620:51;;49496:191;49701:17;49721:29;49737:13;49721;:29;:::i;:::-;49701:49;-1:-1:-1;49769:13:0;;49765:66;;49784:47;49800:4;49814;49821:9;49784:15;:47::i;:::-;49880:13;49855:22;49864:13;49855:6;:22;:::i;:::-;:38;;;;:::i;:::-;49846:47;;49952:13;49930:19;;:35;;;;:::i;:::-;49908:19;:57;50002:19;;:35;;50024:13;;50002:35;:::i;:::-;49980:19;:57;-1:-1:-1;49103:946:0;50059:33;50075:4;50081:2;50085:6;50059:15;:33::i;:::-;50108:16;;-1:-1:-1;;;50108:16:0;;;;50103:487;;-1:-1:-1;;;;;50146:40:0;;;;;;:34;:40;;;;;;;;50141:214;;50246:20;;50237:6;:29;50207:132;;;;-1:-1:-1;;;50207:132:0;;15243:2:1;50207:132:0;;;15225:21:1;15282:2;15262:18;;;15255:30;15321:31;15301:18;;;15294:59;15370:18;;50207:132:0;15041:353:1;50207:132:0;-1:-1:-1;;;;;50374:38:0;;;;;;:34;:38;;;;;;;;50369:210;;50479:9;;50463:13;50473:2;50463:9;:13::i;:::-;:25;50433:130;;;;-1:-1:-1;;;50433:130:0;;15601:2:1;50433:130:0;;;15583:21:1;15640:2;15620:18;;;15613:30;15679:33;15659:18;;;15652:61;15730:18;;50433:130:0;15399:355:1;50433:130:0;48254:2343;;;;;48141:2456;;;:::o;12989:582::-;13319:10;;;13318:62;;-1:-1:-1;13335:39:0;;-1:-1:-1;;;13335:39:0;;13359:4;13335:39;;;7509:34:1;-1:-1:-1;;;;;7579:15:1;;;7559:18;;;7552:43;13335:15:0;;;;;7444:18:1;;13335:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;13318:62;13296:166;;;;-1:-1:-1;;;13296:166:0;;15961:2:1;13296:166:0;;;15943:21:1;16000:2;15980:18;;;15973:30;16039:34;16019:18;;;16012:62;-1:-1:-1;;;16090:18:1;;;16083:52;16152:19;;13296:166:0;15759:418:1;13296:166:0;13500:62;;-1:-1:-1;;;;;16374:32:1;;13500:62:0;;;16356:51:1;16423:18;;;16416:34;;;13473:90:0;;13493:5;;-1:-1:-1;;;13523:22:0;16329:18:1;;13500:62:0;;;;-1:-1:-1;;13500:62:0;;;;;;;;;;;;;;-1:-1:-1;;;;;13500:62:0;-1:-1:-1;;;;;;13500:62:0;;;;;;;;;;13473:19;:90::i;:::-;12989:582;;;:::o;47307:253::-;-1:-1:-1;;;;;47398:31:0;;;;;;:25;:31;;;;;;;;:39;;;;;-1:-1:-1;;47398:39:0;;;;;;;;47448:34;:40;;;;;;:48;;;;;;;;;;47512:40;1266:41:1;;;47512:40:0;;1239:18:1;47512:40:0;1126:187:1;11977:191:0;12070:6;;;-1:-1:-1;;;;;12087:17:0;;;-1:-1:-1;;;;;;12087:17:0;;;;;;;12120:40;;12070:6;;;12087:17;12070:6;;12120:40;;12051:16;;12120:40;12040:128;11977:191;:::o;12595:177::-;12705:58;;-1:-1:-1;;;;;16374:32:1;;12705:58:0;;;16356:51:1;16423:18;;;16416:34;;;12678:86:0;;12698:5;;-1:-1:-1;;;12728:23:0;16329:18:1;;12705:58:0;16182:274:1;50605:2835:0;44115:16;:23;;-1:-1:-1;;;;44115:23:0;-1:-1:-1;;;44115:23:0;;;50735:19:::1;::::0;44115:23;;50735::::1;::::0;50757:1:::1;::::0;50735:23:::1;:::i;:::-;50803:15;::::0;50706:52;;-1:-1:-1;50769:31:0::1;::::0;-1:-1:-1;;;50803:15:0;::::1;;;:106;;50865:18;::::0;50858:51:::1;::::0;-1:-1:-1;;;50858:51:0;;50903:4:::1;50858:51;::::0;::::1;2991::1::0;-1:-1:-1;;;;;50865:18:0;;::::1;::::0;50858:36:::1;::::0;2964:18:1;;50858:51:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50803:106;;;50821:21;50803:106;50983:23;::::0;50769:140;;-1:-1:-1;50939:29:0::1;::::0;-1:-1:-1;;;50983:23:0;::::1;;;50979:1860;;;51023:21;51064:19;;51045:18;:38;;;;:::i;:::-;51023:60:::0;-1:-1:-1;51101:15:0;;51098:74:::1;;51135:37;51158:13;51135:22;:37::i;:::-;51214:15;::::0;51187:24:::1;::::0;-1:-1:-1;;;51214:15:0;::::1;;;:162;;51306:18;::::0;51299:51:::1;::::0;-1:-1:-1;;;51299:51:0;;51344:4:::1;51299:51;::::0;::::1;2991::1::0;51353:23:0;;-1:-1:-1;;;;;51306:18:0::1;::::0;51299:36:::1;::::0;2964:18:1;;51299:51:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:77;;;;:::i;:::-;51214:162;;;51232:47;51256:23:::0;51232:21:::1;:47;:::i;:::-;51187:189;;51391:35;51489:13;51466:19;;51430:16;:55;;;;:::i;:::-;51429:73;;;;:::i;:::-;51391:111:::0;-1:-1:-1;51541:46:0::1;51391:111:::0;51541:16;:46:::1;:::i;:::-;51517:70:::0;-1:-1:-1;51605:29:0;;51602:667:::1;;51657:15;::::0;-1:-1:-1;;;51657:15:0;::::1;;;51654:584;;;51737:15;::::0;51729:69:::1;::::0;51713:12:::1;::::0;51737:15;;::::1;-1:-1:-1::0;;;;;51737:15:0::1;::::0;51766:27;;51713:12;51729:69;51713:12;51729:69;51766:27;51737:15;51729:69:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51712:86;;;51824:7;51821:116;;;51864:49;::::0;;51882:1:::1;5868:25:1::0;;5924:2;5909:18;;5902:34;;;51864:49:0::1;::::0;5841:18:1;51864:49:0::1;;;;;;;51821:116;51673:283;51654:584;;;52049:15;::::0;51990:18:::1;::::0;51983:158:::1;::::0;-1:-1:-1;;;;;51990:18:0;;::::1;::::0;52049:15;;;::::1;;52091:27:::0;51983:39:::1;:158::i;:::-;52169:49;::::0;;52187:1:::1;5868:25:1::0;;5924:2;5909:18;;5902:34;;;52169:49:0::1;::::0;5841:18:1;52169:49:0::1;;;;;;;51654:584;51008:1284;;;50979:1860;;;52316:20:::0;;52313:84:::1;;52355:42;52378:18;52355:22;:42::i;:::-;52436:15;::::0;-1:-1:-1;;;52436:15:0;::::1;;;:162;;52528:18;::::0;52521:51:::1;::::0;-1:-1:-1;;;52521:51:0;;52566:4:::1;52521:51;::::0;::::1;2991::1::0;52575:23:0;;-1:-1:-1;;;;;52528:18:0::1;::::0;52521:36:::1;::::0;2964:18:1;;52521:51:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:77;;;;:::i;:::-;52436:162;;;52454:47;52478:23:::0;52454:21:::1;:47;:::i;:::-;52616:19;::::0;52412:186;;-1:-1:-1;52616:21:0;52613:203:::1;;52657:62;52675:4;52682:15;;;;;;;;;-1:-1:-1::0;;;;;52682:15:0::1;52699:19;;52657:9;:62::i;:::-;52761:19;::::0;52743:41:::1;::::0;;5868:25:1;;;52782:1:0::1;5924:2:1::0;5909:18;;5902:34;52743:41:0::1;::::0;5841:18:1;52743:41:0::1;;;;;;;52613:203;52876:1;52855:18;:22;:51;;;;;52905:1;52881:21;:25;52855:51;52851:216;;;52923:55;52936:18;52956:21;52923:12;:55::i;:::-;52998:57;::::0;;5868:25:1;;;5924:2;5909:18;;5902:34;;;52998:57:0::1;::::0;5841:18:1;52998:57:0::1;;;;;;;52851:216;53099:1;53077:19;:23:::0;;;53111:19:::1;:23:::0;;;53152:24:::1;53170:4;53152:9;:24::i;:::-;:26;53149:283;;;53214:1;53197:7;11503:6:::0;;-1:-1:-1;;;;;11503:6:0;;11430:87;53197:7:::1;-1:-1:-1::0;;;;;53197:19:0::1;;53194:227;;53236:59;53254:4;53261:7;11503:6:::0;;-1:-1:-1;;;;;11503:6:0;;11430:87;53261:7:::1;53270:24;53288:4;53270:9;:24::i;:::-;53236:9;:59::i;:::-;53194:227;;;53336:67;53354:4;53369:6;53378:24;53396:4;53378:9;:24::i;53336:67::-;-1:-1:-1::0;;44161:16:0;:24;;-1:-1:-1;;;;44161:24:0;;;-1:-1:-1;50605:2835:0:o;8105:806::-;-1:-1:-1;;;;;8202:18:0;;8194:68;;;;-1:-1:-1;;;8194:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;8281:16:0;;8273:64;;;;-1:-1:-1;;;8273:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;8423:15:0;;8401:19;8423:15;;;;;;;;;;;8457:21;;;;8449:72;;;;-1:-1:-1;;;8449:72:0;;17185:2:1;8449:72:0;;;17167:21:1;17224:2;17204:18;;;17197:30;17263:34;17243:18;;;17236:62;-1:-1:-1;;;17314:18:1;;;17307:36;17360:19;;8449:72:0;16983:402:1;8449:72:0;-1:-1:-1;;;;;8557:15:0;;;:9;:15;;;;;;;;;;;8575:20;;;8557:38;;8775:13;;;;;;;;;;:23;;;;;;8827:26;;1464:25:1;;;8775:13:0;;8827:26;;1437:18:1;8827:26:0;;;;;;;8866:37;12989:582;15200:649;15624:23;15650:69;15678:4;15650:69;;;;;;;;;;;;;;;;;15658:5;-1:-1:-1;;;;;15650:27:0;;;:69;;;;;:::i;:::-;15624:95;;15738:10;:17;15759:1;15738:22;:56;;;;15775:10;15764:30;;;;;;;;;;;;:::i;:::-;15730:111;;;;-1:-1:-1;;;15730:111:0;;17842:2:1;15730:111:0;;;17824:21:1;17881:2;17861:18;;;17854:30;17920:34;17900:18;;;17893:62;-1:-1:-1;;;17971:18:1;;;17964:40;18021:19;;15730:111:0;17640:406:1;53448:852:0;53544:16;;;53558:1;53544:16;;;;;;;;53520:21;;53544:16;;;;;;;;;;-1:-1:-1;53544:16:0;53520:40;;53589:4;53571;53576:1;53571:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;53571:23:0;;;:7;;;;;;;;;:23;53615:18;;53605:7;;53615:18;;;53605:4;;53615:18;;53605:7;;;;;;:::i;:::-;-1:-1:-1;;;;;53605:28:0;;;:7;;;;;;;;;;;:28;53653:15;;;-1:-1:-1;;;53653:15:0;;;;53649:634;;;53703:10;;53684:269;;-1:-1:-1;;;53684:269:0;;-1:-1:-1;;;;;53703:10:0;;;;53684:81;;:269;;53784:11;;53703:10;;53868:4;;53899;;53923:15;;53684:269;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43093:891;;:::o;53649:634::-;53984:15;;54084:10;;53984:287;;-1:-1:-1;;;53984:287:0;;-1:-1:-1;;;;;53984:15:0;;;;:69;;:287;;54084:10;;;54118:11;;53984:15;;54210:4;;54237:15;;53984:287;;;:::i;54308:795::-;54413:15;;-1:-1:-1;;;54413:15:0;;;;54409:685;;;54463:10;;54444:309;;-1:-1:-1;;;54444:309:0;;54541:4;54444:309;;;20296:34:1;20346:18;;;20339:34;;;54463:10:0;20389:18:1;;;20382:34;;;20432:18;;;20425:34;54697:6:0;20475:19:1;;;20468:44;54723:15:0;20528:19:1;;;20521:35;-1:-1:-1;;;;;54463:10:0;;;;54444:46;;54498:15;;20230:19:1;;54444:309:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;43093:891;;:::o;54409:685::-;54802:10;;54877:18;;54783:299;;-1:-1:-1;;;54783:299:0;;54853:4;54783:299;;;21275:34:1;-1:-1:-1;;;;;54877:18:0;;;21325::1;;;21318:43;21377:18;;;21370:34;;;21420:18;;;21413:34;;;54802:10:0;21463:19:1;;;21456:35;;;21507:19;;;21500:35;55026:6:0;21551:19:1;;;21544:44;55052:15:0;21604:19:1;;;21597:35;54802:10:0;;;54783:43;;21209:19:1;;54783:299:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;933:229::-;1070:12;1102:52;1124:6;1132:4;1138:1;1141:12;1102:21;:52::i;:::-;1095:59;933:229;-1:-1:-1;;;;933:229:0:o;1400:455::-;1570:12;1628:5;1603:21;:30;;1595:81;;;;-1:-1:-1;;;1595:81:0;;21845:2:1;1595:81:0;;;21827:21:1;21884:2;21864:18;;;21857:30;21923:34;21903:18;;;21896:62;-1:-1:-1;;;21974:18:1;;;21967:36;22020:19;;1595:81:0;21643:402:1;1595:81:0;1688:12;1702:23;1729:6;-1:-1:-1;;;;;1729:11:0;1748:5;1755:4;1729:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1687:73;;;;1778:69;1805:6;1813:7;1822:10;1834:12;1778:26;:69::i;:::-;1771:76;1400:455;-1:-1:-1;;;;;;;1400:455:0:o;2949:644::-;3134:12;3163:7;3159:427;;;3191:10;:17;3212:1;3191:22;3187:290;;-1:-1:-1;;;;;380:19:0;;;3401:60;;;;-1:-1:-1;;;3401:60:0;;22544:2:1;3401:60:0;;;22526:21:1;22583:2;22563:18;;;22556:30;22622:31;22602:18;;;22595:59;22671:18;;3401:60:0;22342:353:1;3401:60:0;-1:-1:-1;3498:10:0;3491:17;;3159:427;3541:33;3549:10;3561:12;4071:17;;:21;4067:388;;4303:10;4297:17;4360:15;4347:10;4343:2;4339:19;4332:44;4067:388;4430:12;4423:20;;-1:-1:-1;;;4423:20:0;;;;;;;;:::i;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:1;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:1:o;670:131::-;-1:-1:-1;;;;;745:31:1;;735:42;;725:70;;791:1;788;781:12;806:315;874:6;882;935:2;923:9;914:7;910:23;906:32;903:52;;;951:1;948;941:12;903:52;990:9;977:23;1009:31;1034:5;1009:31;:::i;:::-;1059:5;1111:2;1096:18;;;;1083:32;;-1:-1:-1;;;806:315:1:o;1500:180::-;1559:6;1612:2;1600:9;1591:7;1587:23;1583:32;1580:52;;;1628:1;1625;1618:12;1580:52;-1:-1:-1;1651:23:1;;1500:180;-1:-1:-1;1500:180:1:o;1685:456::-;1762:6;1770;1778;1831:2;1819:9;1810:7;1806:23;1802:32;1799:52;;;1847:1;1844;1837:12;1799:52;1886:9;1873:23;1905:31;1930:5;1905:31;:::i;:::-;1955:5;-1:-1:-1;2012:2:1;1997:18;;1984:32;2025:33;1984:32;2025:33;:::i;:::-;1685:456;;2077:7;;-1:-1:-1;;;2131:2:1;2116:18;;;;2103:32;;1685:456::o;2146:118::-;2232:5;2225:13;2218:21;2211:5;2208:32;2198:60;;2254:1;2251;2244:12;2269:382;2334:6;2342;2395:2;2383:9;2374:7;2370:23;2366:32;2363:52;;;2411:1;2408;2401:12;2363:52;2450:9;2437:23;2469:31;2494:5;2469:31;:::i;:::-;2519:5;-1:-1:-1;2576:2:1;2561:18;;2548:32;2589:30;2548:32;2589:30;:::i;:::-;2638:7;2628:17;;;2269:382;;;;;:::o;3053:247::-;3112:6;3165:2;3153:9;3144:7;3140:23;3136:32;3133:52;;;3181:1;3178;3171:12;3133:52;3220:9;3207:23;3239:31;3264:5;3239:31;:::i;:::-;3289:5;3053:247;-1:-1:-1;;;3053:247:1:o;3305:388::-;3373:6;3381;3434:2;3422:9;3413:7;3409:23;3405:32;3402:52;;;3450:1;3447;3440:12;3402:52;3489:9;3476:23;3508:31;3533:5;3508:31;:::i;:::-;3558:5;-1:-1:-1;3615:2:1;3600:18;;3587:32;3628:33;3587:32;3628:33;:::i;4126:161::-;4193:20;;4253:8;4242:20;;4232:31;;4222:59;;4277:1;4274;4267:12;4222:59;4126:161;;;:::o;4292:256::-;4358:6;4366;4419:2;4407:9;4398:7;4394:23;4390:32;4387:52;;;4435:1;4432;4425:12;4387:52;4458:28;4476:9;4458:28;:::i;:::-;4448:38;;4505:37;4538:2;4527:9;4523:18;4505:37;:::i;:::-;4495:47;;4292:256;;;;;:::o;4553:380::-;4632:1;4628:12;;;;4675;;;4696:61;;4750:4;4742:6;4738:17;4728:27;;4696:61;4803:2;4795:6;4792:14;4772:18;4769:38;4766:161;;4849:10;4844:3;4840:20;4837:1;4830:31;4884:4;4881:1;4874:15;4912:4;4909:1;4902:15;4766:161;;4553:380;;;:::o;4938:127::-;4999:10;4994:3;4990:20;4987:1;4980:31;5030:4;5027:1;5020:15;5054:4;5051:1;5044:15;5070:217;5110:1;5136;5126:132;;5180:10;5175:3;5171:20;5168:1;5161:31;5215:4;5212:1;5205:15;5243:4;5240:1;5233:15;5126:132;-1:-1:-1;5272:9:1;;5070:217::o;6282:125::-;6347:9;;;6368:10;;;6365:36;;;6381:18;;:::i;7041:251::-;7111:6;7164:2;7152:9;7143:7;7139:23;7135:32;7132:52;;;7180:1;7177;7170:12;7132:52;7212:9;7206:16;7231:31;7256:5;7231:31;:::i;8686:184::-;8756:6;8809:2;8797:9;8788:7;8784:23;8780:32;8777:52;;;8825:1;8822;8815:12;8777:52;-1:-1:-1;8848:16:1;;8686:184;-1:-1:-1;8686:184:1:o;10119:170::-;10186:8;10214:10;;;10226;;;10210:27;;10249:11;;;10246:37;;;10263:18;;:::i;:::-;10246:37;10119:170;;;;:::o;13925:401::-;14127:2;14109:21;;;14166:2;14146:18;;;14139:30;14205:34;14200:2;14185:18;;14178:62;-1:-1:-1;;;14271:2:1;14256:18;;14249:35;14316:3;14301:19;;13925:401::o;14331:399::-;14533:2;14515:21;;;14572:2;14552:18;;;14545:30;14611:34;14606:2;14591:18;;14584:62;-1:-1:-1;;;14677:2:1;14662:18;;14655:33;14720:3;14705:19;;14331:399::o;14735:168::-;14808:9;;;14839;;14856:15;;;14850:22;;14836:37;14826:71;;14877:18;;:::i;14908:128::-;14975:9;;;14996:11;;;14993:37;;;15010:18;;:::i;17390:245::-;17457:6;17510:2;17498:9;17489:7;17485:23;17481:32;17478:52;;;17526:1;17523;17516:12;17478:52;17558:9;17552:16;17577:28;17599:5;17577:28;:::i;18183:127::-;18244:10;18239:3;18235:20;18232:1;18225:31;18275:4;18272:1;18265:15;18299:4;18296:1;18289:15;18315:461;18368:3;18406:5;18400:12;18433:6;18428:3;18421:19;18459:4;18488:2;18483:3;18479:12;18472:19;;18525:2;18518:5;18514:14;18546:1;18556:195;18570:6;18567:1;18564:13;18556:195;;;18635:13;;-1:-1:-1;;;;;18631:39:1;18619:52;;18691:12;;;;18726:15;;;;18667:1;18585:9;18556:195;;;-1:-1:-1;18767:3:1;;18315:461;-1:-1:-1;;;;;18315:461:1:o;18781:582::-;19080:6;19069:9;19062:25;19123:6;19118:2;19107:9;19103:18;19096:34;19166:3;19161:2;19150:9;19146:18;19139:31;19043:4;19187:57;19239:3;19228:9;19224:19;19216:6;19187:57;:::i;:::-;-1:-1:-1;;;;;19280:32:1;;;;19275:2;19260:18;;19253:60;-1:-1:-1;19344:3:1;19329:19;19322:35;19179:65;18781:582;-1:-1:-1;;;18781:582:1:o;19368:::-;19696:1;19692;19687:3;19683:11;19679:19;19671:6;19667:32;19656:9;19649:51;19736:6;19731:2;19720:9;19716:18;19709:34;19779:6;19774:2;19763:9;19759:18;19752:34;19822:3;19817:2;19806:9;19802:18;19795:31;19630:4;19843:57;19895:3;19884:9;19880:19;19872:6;19843:57;:::i;:::-;19835:65;;19937:6;19931:3;19920:9;19916:19;19909:35;19368:582;;;;;;;;:::o;20567:306::-;20655:6;20663;20671;20724:2;20712:9;20703:7;20699:23;20695:32;20692:52;;;20740:1;20737;20730:12;20692:52;20769:9;20763:16;20753:26;;20819:2;20808:9;20804:18;20798:25;20788:35;;20863:2;20852:9;20848:18;20842:25;20832:35;;20567:306;;;;;:::o;22050:287::-;22179:3;22217:6;22211:13;22233:66;22292:6;22287:3;22280:4;22272:6;22268:17;22233:66;:::i;:::-;22315:16;;;;;22050:287;-1:-1:-1;;22050:287:1:o

Swarm Source

ipfs://f61ff4765459a8589d3420f08f4cbb36236e10640805029d35888a85f64518cd

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

Shido is an infinitely scalable Layer 1 in the interoperable Cosmos, powered by Tendermint Consensus, EVM and WebAssembly.

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ 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.