Token

TLP (TLP)

ERC-20

Overview

Max Total Supply

135.668996746681652104 TLP

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xfd16ea1d1a5531b1829200f64e8c18f8e9364477

Filtered by Token Holder

0xBBBb870677cAB458cA30A5D086aCA391633d93E0

Balance

0.008223384253881735 TLP

Value

$0.00

0xbbbb870677cab458ca30a5d086aca391633d93e0

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SwapPairV2

Compiler Version

v0.8.6+commit.11564f7e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-11-14
*/

// Sources flattened with hardhat v2.6.7 https://hardhat.org

// File @openzeppelin/contracts/utils/math/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


// File @openzeppelin/contracts/utils/[email protected]

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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


// File @openzeppelin/contracts/token/ERC20/[email protected]

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

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

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

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

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}


// File @openzeppelin/contracts/utils/[email protected]

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

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

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

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

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;


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

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @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, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// File @openzeppelin/contracts/utils/structs/[email protected]

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


// File @openzeppelin/contracts/access/[email protected]

// sp-License-Identifier: MIT

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 {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File contracts/interface/IBoringToken.sol

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IBoringToken is IERC20 {
    function mint(address to, uint256 amount) external;

    function burn(address from, uint256 amount) external;
}


// File contracts/twoway/struct.sol

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

struct SwapInParams {
    address to;
    uint amount1;
    uint feeAmountFix; 
    uint remainAmount;
    address feeToDev;
    uint chainID;
}


// File contracts/interface/ISwapPair.sol

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ISwapPair {
    function mint(address to) external returns (uint256 liquidity);

    function burn(
        address from,
        address to,
        uint256 amount,
        address feeTo,
        uint256 feeAmount
    )
        external
        returns (
            uint256,
            uint256[] memory,
            uint256[] memory
        );

    function token0() external returns (address);

    function swapOut(
        address to,
        uint256 amount,
        uint256 chainid
    ) external; // direction: token0 -> token1 or token1 -> token0

    // function swapIn(
    //     address to,
    //     uint256 amount,
    //     uint256 feeAmountFix,
    //     uint256 remainAmount,
    //     address feeToDev,
    //     uint256 chainid
    // ) external;


    function swapIn(
        SwapInParams memory params
    ) external;

    function getReserves(uint256 chainid) external view returns (uint256, uint256);

    function update() external;

    function diff0() external returns (uint256);

    function addChainIDs(uint256[] memory chainids) external;

    function removeChainIDs(uint256[] memory chainids) external;
}


// File contracts/interface/ISwapPairV1.sol

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;


interface ISwapPairV1 is IERC20 {
    function mint(address to) external returns (uint256 liquidity);

    function burn(
        address from,
        address to,
        uint256 amount,
        address feeTo,
        uint256 feeAmount
    )
        external
        returns (
            uint256,
            uint256[] memory,
            uint256[] memory
        );

    function token0() external returns (address);

    function swapOut(
        address to,
        uint256 amount,
        uint256 chainid
    ) external; // direction: token0 -> token1 or token1 -> token0

    // function swapIn(
    //     address to,
    //     uint256 amount,
    //     uint256 feeAmountFix,
    //     uint256 remainAmount,
    //     address feeToDev,
    //     uint256 chainid
    // ) external;


    function swapIn(
        SwapInParams memory params
    ) external;

    function getReserves(uint256 chainid) external view returns (uint256, uint256);

    function update() external;

    function diff0() external returns (uint256);

    function addChainIDs(uint256[] memory chainids) external;

    function removeChainIDs(uint256[] memory chainids) external;
    function getSupportChainIDs() external view returns(uint256[] memory);
    function getLPAmount(uint256 amount) external view returns (uint256 lpAmount);

    function reserve0() external view returns(uint256);
    function twoWay() external view returns(address);
    function reserve1s(uint256 chainId) external view returns(uint256);
    function totalReserve1s() external view returns(uint256); 
}


// File contracts/lib/SafeDecimalMath.sol

// sp-License-Identifier: MIT
pragma solidity ^0.8.0;

// Libraries

// https://docs.synthetix.io/contracts/SafeDecimalMath
library SafeDecimalMath {
    using SafeMath for uint;

    /* Number of decimal places in the representations. */
    uint8 public constant decimals = 18;
    uint8 public constant highPrecisionDecimals = 27;

    /* The number representing 1.0. */
    uint public constant UNIT = 10**uint(decimals);

    /* The number representing 1.0 for higher fidelity numbers. */
    uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
    uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);

    /**
     * @return Provides an interface to UNIT.
     */
    function unit() external pure returns (uint) {
        return UNIT;
    }

    /**
     * @return Provides an interface to PRECISE_UNIT.
     */
    function preciseUnit() external pure returns (uint) {
        return PRECISE_UNIT;
    }

    /**
     * @return The result of multiplying x and y, interpreting the operands as fixed-point
     * decimals.
     *
     * @dev A unit factor is divided out after the product of x and y is evaluated,
     * so that product must be less than 2**256. As this is an integer division,
     * the internal division always rounds down. This helps save on gas. Rounding
     * is more expensive on gas.
     */
    function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
        /* Divide by UNIT to remove the extra factor introduced by the product. */
        return x.mul(y) / UNIT;
    }

    /**
     * @return The result of safely multiplying x and y, interpreting the operands
     * as fixed-point decimals of the specified precision unit.
     *
     * @dev The operands should be in the form of a the specified unit factor which will be
     * divided out after the product of x and y is evaluated, so that product must be
     * less than 2**256.
     *
     * Unlike multiplyDecimal, this function rounds the result to the nearest increment.
     * Rounding is useful when you need to retain fidelity for small decimal numbers
     * (eg. small fractions or percentages).
     */
    function _multiplyDecimalRound(
        uint x,
        uint y,
        uint precisionUnit
    ) private pure returns (uint) {
        /* Divide by UNIT to remove the extra factor introduced by the product. */
        uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);

        if (quotientTimesTen % 10 >= 5) {
            quotientTimesTen += 10;
        }

        return quotientTimesTen / 10;
    }

    /**
     * @return The result of safely multiplying x and y, interpreting the operands
     * as fixed-point decimals of a precise unit.
     *
     * @dev The operands should be in the precise unit factor which will be
     * divided out after the product of x and y is evaluated, so that product must be
     * less than 2**256.
     *
     * Unlike multiplyDecimal, this function rounds the result to the nearest increment.
     * Rounding is useful when you need to retain fidelity for small decimal numbers
     * (eg. small fractions or percentages).
     */
    function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
        return _multiplyDecimalRound(x, y, PRECISE_UNIT);
    }

    /**
     * @return The result of safely multiplying x and y, interpreting the operands
     * as fixed-point decimals of a standard unit.
     *
     * @dev The operands should be in the standard unit factor which will be
     * divided out after the product of x and y is evaluated, so that product must be
     * less than 2**256.
     *
     * Unlike multiplyDecimal, this function rounds the result to the nearest increment.
     * Rounding is useful when you need to retain fidelity for small decimal numbers
     * (eg. small fractions or percentages).
     */
    function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
        return _multiplyDecimalRound(x, y, UNIT);
    }

    /**
     * @return The result of safely dividing x and y. The return value is a high
     * precision decimal.
     *
     * @dev y is divided after the product of x and the standard precision unit
     * is evaluated, so the product of x and UNIT must be less than 2**256. As
     * this is an integer division, the result is always rounded down.
     * This helps save on gas. Rounding is more expensive on gas.
     */
    function divideDecimal(uint x, uint y) internal pure returns (uint) {
        /* Reintroduce the UNIT factor that will be divided out by y. */
        return x.mul(UNIT).div(y);
    }

    /**
     * @return The result of safely dividing x and y. The return value is as a rounded
     * decimal in the precision unit specified in the parameter.
     *
     * @dev y is divided after the product of x and the specified precision unit
     * is evaluated, so the product of x and the specified precision unit must
     * be less than 2**256. The result is rounded to the nearest increment.
     */
    function _divideDecimalRound(
        uint x,
        uint y,
        uint precisionUnit
    ) private pure returns (uint) {
        uint resultTimesTen = x.mul(precisionUnit * 10).div(y);

        if (resultTimesTen % 10 >= 5) {
            resultTimesTen += 10;
        }

        return resultTimesTen / 10;
    }

    /**
     * @return The result of safely dividing x and y. The return value is as a rounded
     * standard precision decimal.
     *
     * @dev y is divided after the product of x and the standard precision unit
     * is evaluated, so the product of x and the standard precision unit must
     * be less than 2**256. The result is rounded to the nearest increment.
     */
    function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
        return _divideDecimalRound(x, y, UNIT);
    }

    /**
     * @return The result of safely dividing x and y. The return value is as a rounded
     * high precision decimal.
     *
     * @dev y is divided after the product of x and the high precision unit
     * is evaluated, so the product of x and the high precision unit must
     * be less than 2**256. The result is rounded to the nearest increment.
     */
    function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
        return _divideDecimalRound(x, y, PRECISE_UNIT);
    }

    /**
     * @dev Convert a standard decimal representation to a high precision one.
     */
    function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
        return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
    }

    /**
     * @dev Convert a high precision decimal to a standard decimal representation.
     */
    function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
        uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);

        if (quotientTimesTen % 10 >= 5) {
            quotientTimesTen += 10;
        }

        return quotientTimesTen / 10;
    }
}


// File contracts/twoway/SwapPairV2.sol

// sp-License-Identifier: MIT

pragma solidity ^0.8.0;












contract SwapPairV2 is ERC20, Ownable, ISwapPair {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using SafeERC20 for ISwapPairV1;
    using SafeDecimalMath for uint256;
    using EnumerableSet for EnumerableSet.UintSet;

    ISwapPairV1 public oldSwapPair;

    address public override token0; // origin erc20 token

    uint256 public reserve0;

    EnumerableSet.UintSet private supportChainids;
    mapping(uint256 => uint256) public reserve1s;
    uint256 public totalReserve1s;

    address public twoWay;

    uint256 public override diff0;

    event Mint(address indexed sender, uint256 amount);
    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
    event Swap(address indexed sender, uint256 amountIn, uint256 amountOut, address indexed to);

    constructor(
        ISwapPairV1 _oldSwapPair,
        string memory _name,
        string memory _symbol,
        address _token0,
        uint256[] memory chainIds
    ) ERC20(_name, _symbol) {
        oldSwapPair = _oldSwapPair;
        uint256 token0Decimals = IERC20Metadata(_token0).decimals();
        require(token0Decimals < 19, "token0 decimals too big");
        token0 = _token0;
        diff0 = 10**(18 - token0Decimals);
        updateOld(chainIds);
    }

    function updateOld(uint256[] memory chainIds) public onlyOwner {
        updateReserve0();
        updateReserve1s(chainIds);
        updateSupportChainids(chainIds);
        updateTwoWay();
    }

    function updateReserve0() internal {
        reserve0 = oldSwapPair.reserve0();
    }

    function updateReserve1s(uint256[] memory chainIds) internal {
        for (uint256 i; i < chainIds.length; i++) {
            reserve1s[chainIds[i]] = oldSwapPair.reserve1s(chainIds[i]);
        }

        totalReserve1s = oldSwapPair.totalReserve1s();
    }

    function updateSupportChainids(uint256[] memory chainids) internal {
        for (uint256 i; i < chainids.length; i++) {
            supportChainids.add(chainids[i]);
        }
    }

    function updateTwoWay() internal {
        twoWay = oldSwapPair.twoWay();
    }

    function balanceOf(address account) public view override returns (uint256) {
        return super.balanceOf(account) + oldBalanceOf(account);
    }
    function oldBalanceOf(address account) public view returns (uint256) {
        return oldSwapPair.balanceOf(account);
    }

    function totalSupply() public view override returns (uint256) {
        return super.totalSupply() + oldTotalSupply();
    }


    function oldTotalSupply() public view returns (uint256) {
        return oldSwapPair.totalSupply() - oldSwapPair.balanceOf(address(1));
    }

    // ======view=====
    function getReserves(uint256 chainId) public view override returns (uint256, uint256) {
        return (reserve0, reserve1s[chainId]);
    }

    function getSupportChainIDs() external view returns (uint256[] memory) {
        uint256[] memory chainids = new uint256[](supportChainids.length());
        for (uint256 i; i < supportChainids.length(); i++) {
            chainids[i] = supportChainids.at(i);
        }
        return chainids;
    }

    function setTwoWay(address _twoWay) external onlyOwner {
        twoWay = _twoWay;
    }

    function addChainIDs(uint256[] memory chainids) external override onlyTwoWay {
        for (uint256 i; i < chainids.length; i++) {
            supportChainids.add(chainids[i]);
        }
        // emit SupportChaninidsAdded(chainids);
    }

    function removeChainIDs(uint256[] memory chainids) external override onlyTwoWay {
        for (uint256 i; i < chainids.length; i++) {
            supportChainids.remove(chainids[i]);
        }
    }

    function oldMint() public {
        uint256 oldBalance = oldSwapPair.balanceOf(msg.sender);
        if (oldBalance > 0) {
            oldSwapPair.safeTransferFrom(msg.sender, address(1), oldBalance);
            _mint(msg.sender, oldBalance);
        }
    }

    function mint(address to) external override onlyTwoWay needOldMint(to) returns (uint256 lpAmount) {
        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        uint256 amount0 = balance0.sub(reserve0);

        lpAmount = getLPAmount(amount0);

        require(lpAmount > 0, "SwapPair: insufficient liquidity minted");
        _mint(to, lpAmount);
        // update reserves
        reserve0 = balance0;

        emit Mint(msg.sender, lpAmount);
    }

    function getLPAmount(uint256 amount) public view returns (uint256 lpAmount) {
        uint256 amountAdjust = amount * diff0;
        uint256 _reserve0 = reserve0 * diff0;
        uint256 total = totalSupply();
        if (total == 0) {
            lpAmount = amountAdjust;
        } else {
            lpAmount = (amountAdjust * total) / (totalReserve1s + _reserve0);
        }
    }

    function burn(
        address from,
        address to,
        uint256 lpAmount,
        address feeTo,
        uint256 feeAmount
    )
        external
        override
        onlyTwoWay
        needOldMint(from)
        returns (
            uint256,
            uint256[] memory,
            uint256[] memory
        )
    {
        (uint256 amount0, uint256[] memory chainids, uint256[] memory amount1s) = calculateBurn(lpAmount);
        IERC20(token0).safeTransfer(from, amount0 - feeAmount);
        if (feeAmount > 0) {
            IERC20(token0).safeTransfer(feeTo, feeAmount);
        }
        uint256 totalRemove;
        for (uint256 i; i < chainids.length; i++) {
            if (amount1s[i] > 0) {
                reserve1s[chainids[i]] -= amount1s[i];
                totalRemove += amount1s[i];
            }
        }

        _burn(from, lpAmount);

        // current balance
        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        // update reserves
        reserve0 = balance0;
        totalReserve1s -= totalRemove;

        emit Burn(msg.sender, amount0, totalRemove, to);
        return (amount0, chainids, amount1s);
    }

    function calculateBurn(uint256 lpAmount)
        public
        view
        returns (
            uint256,
            uint256[] memory,
            uint256[] memory
        )
    {
        uint256 _reserve0 = reserve0 * diff0;
        uint256 _totalSupply = totalSupply();
        uint256 value = (lpAmount * (_reserve0 + totalReserve1s)) / _totalSupply;

        if (value <= _reserve0) {
            uint256 amount0 = value / diff0;
            uint256[] memory chainids = new uint256[](0);
            uint256[] memory amounts = new uint256[](0);
            return (amount0, chainids, amounts);
        } else {
            uint256 amount = value - _reserve0;
            uint256 chainidLength = supportChainids.length();
            uint256[] memory chainids = new uint256[](chainidLength);
            uint256[] memory amounts = new uint256[](chainidLength);
            for (uint256 i; i < chainidLength; i++) {
                uint256 chainid = supportChainids.at(i);
                if (reserve1s[chainid] >= amount) {
                    chainids[i] = chainid;
                    amounts[i] = amount;
                    break;
                } else {
                    chainids[i] = chainid;
                    amounts[i] = reserve1s[chainid];
                    amount = amount - reserve1s[chainid];
                }
            }
            return (reserve0, chainids, amounts);
        }
    }

    function update() external override onlyTwoWay {
        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        reserve0 = balance0;
    }

    function swapOut(
        address to,
        uint256 amount0,
        uint256 chainID
    ) external override onlyTwoWay onlySupportChainID(chainID) {
        (, uint256 _reserve1) = getReserves(chainID);

        require(_reserve1 >= amount0 * diff0, "SwapPair: insuffient liquidity");

        // IBoringToken(token1).burn(address(this), amount0 * diff0);
        reserve1s[chainID] -= amount0 * diff0;
        totalReserve1s -= amount0 * diff0;

        // current balance
        uint256 balance0 = IERC20(token0).balanceOf(address(this));

        reserve0 = balance0;

        emit Swap(msg.sender, amount0, amount0 * diff0, to);
    }

    function swapIn(SwapInParams memory params) external override onlyTwoWay onlySupportChainID(params.chainID) {
        uint256 _reserve0 = reserve0;

        require(_reserve0 >= params.amount1, "Insuffient liquidity");
        require(params.amount1 > 0, "Swap amount should be greater than 0");

        IERC20(token0).safeTransfer(params.to, params.remainAmount);
        if (params.feeAmountFix > 0) {
            IERC20(token0).safeTransfer(params.feeToDev, params.feeAmountFix);
        }
        // IBoringToken(token1).mint(address(this), amount1 * diff0);
        reserve1s[params.chainID] += params.amount1 * diff0;
        totalReserve1s += params.amount1 * diff0;

        // current balance
        uint256 balance0 = IERC20(token0).balanceOf(address(this));

        reserve0 = balance0;

        emit Swap(msg.sender, params.amount1 * diff0, params.amount1 * diff0, params.to);
    }

    modifier onlyTwoWay() {
        require(msg.sender == twoWay, "SwapPair: only twoWay can invoke it");
        _;
    }

    modifier onlySupportChainID(uint256 chainID) {
        require(supportChainids.contains(chainID), "not support chainID");
        _;
    }

    modifier needOldMint(address acc) {
        uint256 oldBalance = oldSwapPair.balanceOf(acc);
        if (oldBalance > 0) {
            oldSwapPair.safeTransferFrom(acc, address(1), oldBalance);
            _mint(acc, oldBalance);
        }
        _;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"contract ISwapPairV1","name":"_oldSwapPair","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_token0","type":"address"},{"internalType":"uint256[]","name":"chainIds","type":"uint256[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","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":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"chainids","type":"uint256[]"}],"name":"addChainIDs","outputs":[],"stateMutability":"nonpayable","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":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"lpAmount","type":"uint256"},{"internalType":"address","name":"feeTo","type":"address"},{"internalType":"uint256","name":"feeAmount","type":"uint256"}],"name":"burn","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"lpAmount","type":"uint256"}],"name":"calculateBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"diff0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getLPAmount","outputs":[{"internalType":"uint256","name":"lpAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"}],"name":"getReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSupportChainIDs","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"lpAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"oldBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oldMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oldSwapPair","outputs":[{"internalType":"contract ISwapPairV1","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oldTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"chainids","type":"uint256[]"}],"name":"removeChainIDs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reserve0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"reserve1s","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_twoWay","type":"address"}],"name":"setTwoWay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"uint256","name":"feeAmountFix","type":"uint256"},{"internalType":"uint256","name":"remainAmount","type":"uint256"},{"internalType":"address","name":"feeToDev","type":"address"},{"internalType":"uint256","name":"chainID","type":"uint256"}],"internalType":"struct SwapInParams","name":"params","type":"tuple"}],"name":"swapIn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"chainID","type":"uint256"}],"name":"swapOut","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReserve1s","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"twoWay","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"update","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"chainIds","type":"uint256[]"}],"name":"updateOld","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000009312142efba17ce795f95e17076b0800d14a3b1900000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec700000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000003544c5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003544c50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000a86a00000000000000000000000000000000000000000000000000000000000000420000000000000000000000000000000000000000000000000000000063564c400000000000000000000000000000000000000000000000000000000000000089000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000fa0000000000000000000000000000000000000000000000000000000000000064

-----Decoded View---------------
Arg [0] : _oldSwapPair (address): 0x9312142EfbA17Ce795F95E17076B0800D14a3b19
Arg [1] : _name (string): TLP
Arg [2] : _symbol (string): TLP
Arg [3] : _token0 (address): 0xdAC17F958D2ee523a2206206994597C13D831ec7
Arg [4] : chainIds (uint256[]): 56,43114,66,1666600000,137,128,250,100

-----Encoded View---------------
18 Constructor Arguments found :
Arg [0] : 0000000000000000000000009312142efba17ce795f95e17076b0800d14a3b19
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [3] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [6] : 544c500000000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [8] : 544c500000000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000038
Arg [11] : 000000000000000000000000000000000000000000000000000000000000a86a
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000042
Arg [13] : 0000000000000000000000000000000000000000000000000000000063564c40
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000089
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [16] : 00000000000000000000000000000000000000000000000000000000000000fa
Arg [17] : 0000000000000000000000000000000000000000000000000000000000000064

Deployed Bytecode Sourcemap

61517:9962:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13608:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15775:169;;;;;;:::i;:::-;;:::i;:::-;;;7315:14:1;;7308:22;7290:41;;7278:2;7263:18;15775:169:0;7245:92:1;61771:30:0;;;;;-1:-1:-1;;;;;61771:30:0;;;;;;-1:-1:-1;;;;;6181:32:1;;;6163:51;;6151:2;6136:18;61771:30:0;6118:102:1;64777:90:0;;;;;;:::i;:::-;;:::i;:::-;;61810:30;;;;;-1:-1:-1;;;;;61810:30:0;;;64002:126;;;:::i;:::-;;;16326:25:1;;;16314:2;16299:18;64002:126:0;16281:76:1;64875:246:0;;;;;;:::i;:::-;;:::i;65339:264::-;;;:::i;16426:492::-;;;;;;:::i;:::-;;:::i;65129:202::-;;;;;;:::i;:::-;;:::i;14570:93::-;;;14653:2;17298:36:1;;17286:2;17271:18;14570:93:0;17253:87:1;17327:215:0;;;;;;:::i;:::-;;:::i;62044:21::-;;;;;-1:-1:-1;;;;;62044:21:0;;;61871:23;;;;;;65611:479;;;;;;:::i;:::-;;:::i;61955:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;64138:143;;;:::i;63714:149::-;;;;;;:::i;:::-;;:::i;49893:94::-;;;:::i;69341:661::-;;;;;;:::i;:::-;;:::i;66498:1211::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;62854:201::-;;;;;;:::i;:::-;;:::i;70010:917::-;;;;;;:::i;:::-;;:::i;62006:29::-;;;;;;49242:87;49315:6;;-1:-1:-1;;;;;49315:6:0;49242:87;;64313:142;;;;;;:::i;:::-;64418:8;;64381:7;64428:18;;;:9;:18;;;;;;;64418:8;;64313:142;;;;;17077:25:1;;;17133:2;17118:18;;17111:34;;;;17050:18;64313:142:0;17032:119:1;13827:104:0;;;:::i;69179:154::-;;;:::i;18045:413::-;;;;;;:::i;:::-;;:::i;15239:175::-;;;;;;:::i;:::-;;:::i;66098:392::-;;;;;;:::i;:::-;;:::i;63869:125::-;;;;;;:::i;:::-;;:::i;62074:29::-;;;;;;64463:306;;;:::i;:::-;;;;;;;:::i;67717:1454::-;;;;;;:::i;:::-;;:::i;15477:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;15593:18:0;;;15566:7;15593:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15477:151;50142:192;;;;;;:::i;:::-;;:::i;13608:100::-;13662:13;13695:5;13688:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13608:100;:::o;15775:169::-;15858:4;15875:39;11366:10;15898:7;15907:6;15875:8;:39::i;:::-;-1:-1:-1;15932:4:0;15775:169;;;;;:::o;64777:90::-;49315:6;;-1:-1:-1;;;;;49315:6:0;11366:10;49462:23;49454:68;;;;-1:-1:-1;;;49454:68:0;;;;;;;:::i;:::-;;;;;;;;;64843:6:::1;:16:::0;;-1:-1:-1;;;;;;64843:16:0::1;-1:-1:-1::0;;;;;64843:16:0;;;::::1;::::0;;;::::1;::::0;;64777:90::o;64002:126::-;64055:7;64104:16;:14;:16::i;:::-;14816:12;;64082:38;;;;:::i;:::-;64075:45;;64002:126;:::o;64875:246::-;70990:6;;-1:-1:-1;;;;;70990:6:0;70976:10;:20;70968:68;;;;-1:-1:-1;;;70968:68:0;;;;;;;:::i;:::-;64968:9:::1;64963:101;64983:8;:15;64979:1;:19;64963:101;;;65020:32;65040:8;65049:1;65040:11;;;;;;;;:::i;:::-;;;;;;;65020:15;:19;;:32;;;;:::i;:::-;-1:-1:-1::0;65000:3:0;::::1;::::0;::::1;:::i;:::-;;;;64963:101;;;;64875:246:::0;:::o;65339:264::-;65397:11;;:33;;-1:-1:-1;;;65397:33:0;;65419:10;65397:33;;;6163:51:1;65376:18:0;;-1:-1:-1;;;;;65397:11:0;;:21;;6136:18:1;;65397:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65376:54;-1:-1:-1;65445:14:0;;65441:155;;65476:11;;:64;;-1:-1:-1;;;;;65476:11:0;65505:10;65525:1;65529:10;65476:28;:64::i;:::-;65555:29;65561:10;65573;65555:5;:29::i;:::-;65365:238;65339:264::o;16426:492::-;16566:4;16583:36;16593:6;16601:9;16612:6;16583:9;:36::i;:::-;-1:-1:-1;;;;;16659:19:0;;16632:24;16659:19;;;:11;:19;;;;;;;;11366:10;16659:33;;;;;;;;16711:26;;;;16703:79;;;;-1:-1:-1;;;16703:79:0;;12516:2:1;16703:79:0;;;12498:21:1;12555:2;12535:18;;;12528:30;12594:34;12574:18;;;12567:62;-1:-1:-1;;;12645:18:1;;;12638:38;12693:19;;16703:79:0;12488:230:1;16703:79:0;16818:57;16827:6;11366:10;16868:6;16849:16;:25;16818:8;:57::i;:::-;16906:4;16899:11;;;16426:492;;;;;;:::o;65129:202::-;70990:6;;-1:-1:-1;;;;;70990:6:0;70976:10;:20;70968:68;;;;-1:-1:-1;;;70968:68:0;;;;;;;:::i;:::-;65225:9:::1;65220:104;65240:8;:15;65236:1;:19;65220:104;;;65277:35;65300:8;65309:1;65300:11;;;;;;;;:::i;:::-;;;;;;;65277:15;:22;;:35;;;;:::i;:::-;-1:-1:-1::0;65257:3:0;::::1;::::0;::::1;:::i;:::-;;;;65220:104;;17327:215:::0;11366:10;17415:4;17464:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;17464:34:0;;;;;;;;;;17415:4;;17432:80;;17455:7;;17464:47;;17501:10;;17464:47;:::i;:::-;17432:8;:80::i;65611:479::-;70990:6;;65691:16;;-1:-1:-1;;;;;70990:6:0;70976:10;:20;70968:68;;;;-1:-1:-1;;;70968:68:0;;;;;;;:::i;:::-;71279:11:::1;::::0;:26:::1;::::0;-1:-1:-1;;;71279:26:0;;-1:-1:-1;;;;;6181:32:1;;;71279:26:0::1;::::0;::::1;6163:51:1::0;65678:2:0;;71258:18:::1;::::0;71279:11;::::1;::::0;:21:::1;::::0;6136:18:1;;71279:26:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;71258:47:::0;-1:-1:-1;71320:14:0;;71316:141:::1;;71351:11;::::0;:57:::1;::::0;-1:-1:-1;;;;;71351:11:0::1;71380:3:::0;71393:1:::1;71397:10:::0;71351:28:::1;:57::i;:::-;71423:22;71429:3;71434:10;71423:5;:22::i;:::-;65746:6:::2;::::0;65739:39:::2;::::0;-1:-1:-1;;;65739:39:0;;65772:4:::2;65739:39;::::0;::::2;6163:51:1::0;65720:16:0::2;::::0;-1:-1:-1;;;;;65746:6:0::2;::::0;65739:24:::2;::::0;6136:18:1;;65739:39:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65720:58;;65789:15;65807:22;65820:8;;65807;:12;;:22;;;;:::i;:::-;65789:40;;65853:20;65865:7;65853:11;:20::i;:::-;65842:31;;65905:1;65894:8;:12;65886:64;;;::::0;-1:-1:-1;;;65886:64:0;;10993:2:1;65886:64:0::2;::::0;::::2;10975:21:1::0;11032:2;11012:18;;;11005:30;11071:34;11051:18;;;11044:62;-1:-1:-1;;;11122:18:1;;;11115:37;11169:19;;65886:64:0::2;10965:229:1::0;65886:64:0::2;65961:19;65967:2;65971:8;65961:5;:19::i;:::-;66019:8;:19:::0;;;66056:26:::2;::::0;16326:25:1;;;66061:10:0::2;::::0;66056:26:::2;::::0;16314:2:1;16299:18;66056:26:0::2;;;;;;;65709:381;;71247:229:::1;71047:1;65611:479:::0;;;:::o;64138:143::-;64240:11;;:33;;-1:-1:-1;;;64240:33:0;;:11;:33;;;6163:51:1;64185:7:0;;-1:-1:-1;;;;;64240:11:0;;:21;;6136:18:1;;64240:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64212:11;;;;;;;;;-1:-1:-1;;;;;64212:11:0;-1:-1:-1;;;;;64212:23:0;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:61;;;;:::i;63714:149::-;63780:7;63834:21;63847:7;63834:12;:21::i;:::-;-1:-1:-1;;;;;15000:18:0;;14973:7;15000:18;;;;;;;;;;;63807:48;;;;:::i;49893:94::-;49315:6;;-1:-1:-1;;;;;49315:6:0;11366:10;49462:23;49454:68;;;;-1:-1:-1;;;49454:68:0;;;;;;;:::i;:::-;49958:21:::1;49976:1;49958:9;:21::i;:::-;49893:94::o:0;69341:661::-;70990:6;;-1:-1:-1;;;;;70990:6:0;70976:10;:20;70968:68;;;;-1:-1:-1;;;70968:68:0;;;;;;;:::i;:::-;69486:7;71128:33:::1;:15;69486:7:::0;71128:24:::1;:33::i;:::-;71120:65;;;::::0;-1:-1:-1;;;71120:65:0;;12925:2:1;71120:65:0::1;::::0;::::1;12907:21:1::0;12964:2;12944:18;;;12937:30;-1:-1:-1;;;12983:18:1;;;12976:49;13042:18;;71120:65:0::1;12897:169:1::0;71120:65:0::1;69509:17:::2;64428:18:::0;;;:9;:18;;;;;;69594:5:::2;::::0;69584:15:::2;::::0;:7;:15:::2;:::i;:::-;69571:9;:28;;69563:71;;;::::0;-1:-1:-1;;;69563:71:0;;12157:2:1;69563:71:0::2;::::0;::::2;12139:21:1::0;12196:2;12176:18;;;12169:30;12235:32;12215:18;;;12208:60;12285:18;;69563:71:0::2;12129:180:1::0;69563:71:0::2;69750:5;::::0;69740:15:::2;::::0;:7;:15:::2;:::i;:::-;69718:18;::::0;;;:9:::2;:18;::::0;;;;:37;;:18;;;:37:::2;::::0;;;::::2;:::i;:::-;::::0;;;-1:-1:-1;;69794:5:0::2;::::0;69784:15:::2;::::0;:7;:15:::2;:::i;:::-;69766:14;;:33;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;69866:6:0::2;::::0;69859:39:::2;::::0;-1:-1:-1;;;69859:39:0;;69892:4:::2;69859:39;::::0;::::2;6163:51:1::0;69840:16:0::2;::::0;-1:-1:-1;;;;;69866:6:0::2;::::0;69859:24:::2;::::0;6136:18:1;;69859:39:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;69840:58;;69922:8;69911;:19;;;;69991:2;-1:-1:-1::0;;;;;69948:46:0::2;69953:10;-1:-1:-1::0;;;;;69948:46:0::2;;69965:7;69984:5;;69974:7;:15;;;;:::i;:::-;69948:46;::::0;;17077:25:1;;;17133:2;17118:18;;17111:34;;;;17050:18;69948:46:0::2;;;;;;;69495:507;;71047:1:::1;69341:661:::0;;;:::o;66498:1211::-;70990:6;;66757:7;;66779:16;;;;-1:-1:-1;;;;;70990:6:0;70976:10;:20;70968:68;;;;-1:-1:-1;;;70968:68:0;;;;;;;:::i;:::-;71279:11:::1;::::0;:26:::1;::::0;-1:-1:-1;;;71279:26:0;;-1:-1:-1;;;;;6181:32:1;;;71279:26:0::1;::::0;::::1;6163:51:1::0;66719:4:0;;71258:18:::1;::::0;71279:11;::::1;::::0;:21:::1;::::0;6136:18:1;;71279:26:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;71258:47:::0;-1:-1:-1;71320:14:0;;71316:141:::1;;71351:11;::::0;:57:::1;::::0;-1:-1:-1;;;;;71351:11:0::1;71380:3:::0;71393:1:::1;71397:10:::0;71351:28:::1;:57::i;:::-;71423:22;71429:3;71434:10;71423:5;:22::i;:::-;66855:15:::2;66872:25:::0;66899::::2;66928:23;66942:8;66928:13;:23::i;:::-;66854:97:::0;;-1:-1:-1;66854:97:0;-1:-1:-1;66854:97:0;-1:-1:-1;66962:54:0::2;66990:4:::0;66996:19:::2;67006:9:::0;66854:97;66996:19:::2;:::i;:::-;66969:6;::::0;-1:-1:-1;;;;;66969:6:0::2;::::0;66962:54;:27:::2;:54::i;:::-;67031:13:::0;;67027:91:::2;;67068:6;::::0;67061:45:::2;::::0;-1:-1:-1;;;;;67068:6:0::2;67089:5:::0;67096:9;67061:27:::2;:45::i;:::-;67128:19;67163:9:::0;67158:206:::2;67178:8;:15;67174:1;:19;67158:206;;;67233:1;67219:8;67228:1;67219:11;;;;;;;;:::i;:::-;;;;;;;:15;67215:138;;;67281:8;67290:1;67281:11;;;;;;;;:::i;:::-;;;;;;;67255:9;:22;67265:8;67274:1;67265:11;;;;;;;;:::i;:::-;;;;;;;67255:22;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;67326:8;67335:1;67326:11;;;;;;;;:::i;:::-;;;;;;;67311:26;;;;;:::i;:::-;;;67215:138;67195:3:::0;::::2;::::0;::::2;:::i;:::-;;;;67158:206;;;;67376:21;67382:4;67388:8;67376:5;:21::i;:::-;67464:6;::::0;67457:39:::2;::::0;-1:-1:-1;;;67457:39:0;;67490:4:::2;67457:39;::::0;::::2;6163:51:1::0;67438:16:0::2;::::0;-1:-1:-1;;;;;67464:6:0::2;::::0;67457:24:::2;::::0;6136:18:1;;67457:39:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67438:58;;67546:8;67535;:19;;;;67583:11;67565:14;;:29;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;67612:42:0::2;::::0;-1:-1:-1;;;;;67612:42:0;::::2;::::0;67617:10:::2;::::0;67612:42:::2;::::0;::::2;::::0;67629:7;;67638:11;;17077:25:1;;;17133:2;17118:18;;17111:34;17065:2;17050:18;;17032:119;67612:42:0::2;;;;;;;;-1:-1:-1::0;67673:7:0;;67682:8;;-1:-1:-1;67682:8:0;-1:-1:-1;66498:1211:0;-1:-1:-1;;;;;;;;;66498:1211:0:o;62854:201::-;49315:6;;-1:-1:-1;;;;;49315:6:0;11366:10;49462:23;49454:68;;;;-1:-1:-1;;;49454:68:0;;;;;;;:::i;:::-;62928:16:::1;:14;:16::i;:::-;62955:25;62971:8;62955:15;:25::i;:::-;62991:31;63013:8;62991:21;:31::i;:::-;63033:14;:12;:14::i;70010:917::-:0;70990:6;;-1:-1:-1;;;;;70990:6:0;70976:10;:20;70968:68;;;;-1:-1:-1;;;70968:68:0;;;;;;;:::i;:::-;70102:14:::1;::::0;::::1;::::0;71128:33:::1;:15;70102:14:::0;71128:24:::1;:33::i;:::-;71120:65;;;::::0;-1:-1:-1;;;71120:65:0;;12925:2:1;71120:65:0::1;::::0;::::1;12907:21:1::0;12964:2;12944:18;;;12937:30;-1:-1:-1;;;12983:18:1;;;12976:49;13042:18;;71120:65:0::1;12897:169:1::0;71120:65:0::1;70149:8:::2;::::0;70191:14:::2;::::0;::::2;::::0;70178:27;::::2;;70170:60;;;::::0;-1:-1:-1;;;70170:60:0;;11808:2:1;70170:60:0::2;::::0;::::2;11790:21:1::0;11847:2;11827:18;;;11820:30;-1:-1:-1;;;11866:18:1;;;11859:50;11926:18;;70170:60:0::2;11780:170:1::0;70170:60:0::2;70266:1;70249:6;:14;;;:18;70241:67;;;::::0;-1:-1:-1;;;70241:67:0;;9777:2:1;70241:67:0::2;::::0;::::2;9759:21:1::0;9816:2;9796:18;;;9789:30;9855:34;9835:18;;;9828:62;-1:-1:-1;;;9906:18:1;;;9899:34;9950:19;;70241:67:0::2;9749:226:1::0;70241:67:0::2;70349:9:::0;;70360:19:::2;::::0;::::2;::::0;70328:6:::2;::::0;70321:59:::2;::::0;-1:-1:-1;;;;;70328:6:0;;::::2;::::0;70321:27:::2;:59::i;:::-;70395:19;::::0;::::2;::::0;:23;70391:121:::2;;70463:15;::::0;::::2;::::0;70480:19:::2;::::0;::::2;::::0;70442:6:::2;::::0;70435:65:::2;::::0;-1:-1:-1;;;;;70442:6:0;;::::2;::::0;70435:27:::2;:65::i;:::-;70639:5;;70622:6;:14;;;:22;;;;:::i;:::-;70603:14;::::0;::::2;::::0;70593:25:::2;::::0;;;:9:::2;:25;::::0;;;;:51;;:25;;;:51:::2;::::0;;;::::2;:::i;:::-;::::0;;;-1:-1:-1;;70690:5:0::2;::::0;70673:14:::2;::::0;::::2;::::0;:22:::2;::::0;70690:5;70673:22:::2;:::i;:::-;70655:14;;:40;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;70762:6:0::2;::::0;70755:39:::2;::::0;-1:-1:-1;;;70755:39:0;;70788:4:::2;70755:39;::::0;::::2;6163:51:1::0;70736:16:0::2;::::0;-1:-1:-1;;;;;70762:6:0::2;::::0;70755:24:::2;::::0;6136:18:1;;70755:39:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70736:58;;70818:8;70807;:19;;;;70909:6;:9;;;-1:-1:-1::0;;;;;70844:75:0::2;70849:10;-1:-1:-1::0;;;;;70844:75:0::2;;70878:5;;70861:6;:14;;;:22;;;;:::i;:::-;70902:5;;70885:6;:14;;;:22;;;;:::i;:::-;70844:75;::::0;;17077:25:1;;;17133:2;17118:18;;17111:34;;;;17050:18;70844:75:0::2;;;;;;;70118:809;;71047:1:::1;70010:917:::0;:::o;13827:104::-;13883:13;13916:7;13909:14;;;;;:::i;69179:154::-;70990:6;;-1:-1:-1;;;;;70990:6:0;70976:10;:20;70968:68;;;;-1:-1:-1;;;70968:68:0;;;;;;;:::i;:::-;69263:6:::1;::::0;69256:39:::1;::::0;-1:-1:-1;;;69256:39:0;;69289:4:::1;69256:39;::::0;::::1;6163:51:1::0;69237:16:0::1;::::0;-1:-1:-1;;;;;69263:6:0::1;::::0;69256:24:::1;::::0;6136:18:1;;69256:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;69306:8;:19:::0;-1:-1:-1;69179:154:0:o;18045:413::-;11366:10;18138:4;18182:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;18182:34:0;;;;;;;;;;18235:35;;;;18227:85;;;;-1:-1:-1;;;18227:85:0;;15616:2:1;18227:85:0;;;15598:21:1;15655:2;15635:18;;;15628:30;15694:34;15674:18;;;15667:62;-1:-1:-1;;;15745:18:1;;;15738:35;15790:19;;18227:85:0;15588:227:1;18227:85:0;18348:67;11366:10;18371:7;18399:15;18380:16;:34;18348:8;:67::i;:::-;-1:-1:-1;18446:4:0;;18045:413;-1:-1:-1;;;18045:413:0:o;15239:175::-;15325:4;15342:42;11366:10;15366:9;15377:6;15342:9;:42::i;66098:392::-;66156:16;66185:20;66217:5;;66208:6;:14;;;;:::i;:::-;66185:37;;66233:17;66264:5;;66253:8;;:16;;;;:::i;:::-;66233:36;;66280:13;66296;:11;:13::i;:::-;66280:29;-1:-1:-1;66324:10:0;66320:163;;66362:12;66351:23;;66320:163;;;66461:9;66444:14;;:26;;;;:::i;:::-;66419:20;66434:5;66419:12;:20;:::i;:::-;66418:53;;;;:::i;:::-;66407:64;;66320:163;66174:316;;;66098:392;;;:::o;63869:125::-;63956:11;;:30;;-1:-1:-1;;;63956:30:0;;-1:-1:-1;;;;;6181:32:1;;;63956:30:0;;;6163:51:1;63929:7:0;;63956:11;;:21;;6136:18:1;;63956:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;64463:306::-;64516:16;64545:25;64587:24;:15;:22;:24::i;:::-;64573:39;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64573:39:0;;64545:67;;64628:9;64623:113;64643:24;:15;:22;:24::i;:::-;64639:1;:28;64623:113;;;64703:21;:15;64722:1;64703:18;:21::i;:::-;64689:8;64698:1;64689:11;;;;;;;;:::i;:::-;;;;;;;;;;:35;64669:3;;;;:::i;:::-;;;;64623:113;;;-1:-1:-1;64753:8:0;64463:306;-1:-1:-1;64463:306:0:o;67717:1454::-;67820:7;67842:16;67873;67917:17;67948:5;;67937:8;;:16;;;;:::i;:::-;67917:36;;67964:20;67987:13;:11;:13::i;:::-;67964:36;;68011:13;68071:12;68052:14;;68040:9;:26;;;;:::i;:::-;68028:39;;:8;:39;:::i;:::-;68027:56;;;;:::i;:::-;68011:72;;68109:9;68100:5;:18;68096:1068;;68135:15;68161:5;;68153;:13;;;;:::i;:::-;68209:16;;;68181:25;68209:16;;;;;;68267;;;;;;;;;68135:31;;-1:-1:-1;68209:16:0;;-1:-1:-1;68209:16:0;-1:-1:-1;68298:35:0;;-1:-1:-1;;;;68298:35:0;68096:1068;68366:14;68383:17;68391:9;68383:5;:17;:::i;:::-;68366:34;;68415:21;68439:24;:15;:22;:24::i;:::-;68415:48;;68478:25;68520:13;68506:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68506:28:0;;68478:56;;68549:24;68590:13;68576:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68576:28:0;;68549:55;;68624:9;68619:483;68639:13;68635:1;:17;68619:483;;;68678:15;68696:21;:15;68715:1;68696:18;:21::i;:::-;68740:18;;;;:9;:18;;;;;;68678:39;;-1:-1:-1;68740:28:0;-1:-1:-1;68736:351:0;;68807:7;68793:8;68802:1;68793:11;;;;;;;;:::i;:::-;;;;;;:21;;;;;68850:6;68837:7;68845:1;68837:10;;;;;;;;:::i;:::-;;;;;;:19;;;;;68879:5;;;68736:351;68947:7;68933:8;68942:1;68933:11;;;;;;;;:::i;:::-;;;;;;:21;;;;;68990:9;:18;69000:7;68990:18;;;;;;;;;;;;68977:7;68985:1;68977:10;;;;;;;;:::i;:::-;;;;;;:31;;;;;69049:9;:18;69059:7;69049:18;;;;;;;;;;;;69040:6;:27;;;;:::i;:::-;69031:36;;-1:-1:-1;68654:3:0;;;;:::i;:::-;;;;68619:483;;;-1:-1:-1;69124:8:0;;;-1:-1:-1;69134:8:0;;-1:-1:-1;69144:7:0;-1:-1:-1;69116:36:0;;-1:-1:-1;;;;;69116:36:0;67717:1454;;;;;;:::o;50142:192::-;49315:6;;-1:-1:-1;;;;;49315:6:0;11366:10;49462:23;49454:68;;;;-1:-1:-1;;;49454:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50231:22:0;::::1;50223:73;;;::::0;-1:-1:-1;;;50223:73:0;;8967:2:1;50223:73:0::1;::::0;::::1;8949:21:1::0;9006:2;8986:18;;;8979:30;9045:34;9025:18;;;9018:62;-1:-1:-1;;;9096:18:1;;;9089:36;9142:19;;50223:73:0::1;8939:228:1::0;50223:73:0::1;50307:19;50317:8;50307:9;:19::i;46022:131::-:0;46089:4;46113:32;46118:3;46138:5;46113:4;:32::i;21729:380::-;-1:-1:-1;;;;;21865:19:0;;21857:68;;;;-1:-1:-1;;;21857:68:0;;14442:2:1;21857:68:0;;;14424:21:1;14481:2;14461:18;;;14454:30;14520:34;14500:18;;;14493:62;-1:-1:-1;;;14571:18:1;;;14564:34;14615:19;;21857:68:0;14414:226:1;21857:68:0;-1:-1:-1;;;;;21944:21:0;;21936:68;;;;-1:-1:-1;;;21936:68:0;;9374:2:1;21936:68:0;;;9356:21:1;9413:2;9393:18;;;9386:30;9452:34;9432:18;;;9425:62;-1:-1:-1;;;9503:18:1;;;9496:32;9545:19;;21936:68:0;9346:224:1;21936:68:0;-1:-1:-1;;;;;22017:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;22069:32;;16326:25:1;;;22069:32:0;;16299:18:1;22069:32:0;;;;;;;21729:380;;;:::o;32586:248::-;32757:68;;-1:-1:-1;;;;;6483:15:1;;;32757:68:0;;;6465:34:1;6535:15;;6515:18;;;6508:43;6567:18;;;6560:34;;;32730:96:0;;32750:5;;-1:-1:-1;;;32780:27:0;6400:18:1;;32757:68:0;;;;-1:-1:-1;;32757:68:0;;;;;;;;;;;;;;-1:-1:-1;;;;;32757:68:0;-1:-1:-1;;;;;;32757:68:0;;;;;;;;;;32730:19;:96::i;:::-;32586:248;;;;:::o;19968:399::-;-1:-1:-1;;;;;20052:21:0;;20044:65;;;;-1:-1:-1;;;20044:65:0;;16022:2:1;20044:65:0;;;16004:21:1;16061:2;16041:18;;;16034:30;16100:33;16080:18;;;16073:61;16151:18;;20044:65:0;15994:181:1;20044:65:0;20200:6;20184:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;20217:18:0;;:9;:18;;;;;;;;;;:28;;20239:6;;20217:9;:28;;20239:6;;20217:28;:::i;:::-;;;;-1:-1:-1;;20261:37:0;;16326:25:1;;;-1:-1:-1;;;;;20261:37:0;;;20278:1;;20261:37;;16314:2:1;16299:18;20261:37:0;;;;;;;64963:101:::1;64875:246:::0;:::o;18948:733::-;-1:-1:-1;;;;;19088:20:0;;19080:70;;;;-1:-1:-1;;;19080:70:0;;14036:2:1;19080:70:0;;;14018:21:1;14075:2;14055:18;;;14048:30;14114:34;14094:18;;;14087:62;-1:-1:-1;;;14165:18:1;;;14158:35;14210:19;;19080:70:0;14008:227:1;19080:70:0;-1:-1:-1;;;;;19169:23:0;;19161:71;;;;-1:-1:-1;;;19161:71:0;;8160:2:1;19161:71:0;;;8142:21:1;8199:2;8179:18;;;8172:30;8238:34;8218:18;;;8211:62;-1:-1:-1;;;8289:18:1;;;8282:33;8332:19;;19161:71:0;8132:225:1;19161:71:0;-1:-1:-1;;;;;19329:17:0;;19305:21;19329:17;;;;;;;;;;;19365:23;;;;19357:74;;;;-1:-1:-1;;;19357:74:0;;10586:2:1;19357:74:0;;;10568:21:1;10625:2;10605:18;;;10598:30;10664:34;10644:18;;;10637:62;-1:-1:-1;;;10715:18:1;;;10708:36;10761:19;;19357:74:0;10558:228:1;19357:74:0;-1:-1:-1;;;;;19467:17:0;;;:9;:17;;;;;;;;;;;19487:22;;;19467:42;;19531:20;;;;;;;;:30;;19503:6;;19467:9;19531:30;;19503:6;;19531:30;:::i;:::-;;;;;;;;19596:9;-1:-1:-1;;;;;19579:35:0;19588:6;-1:-1:-1;;;;;19579:35:0;;19607:6;19579:35;;;;16326:25:1;;16314:2;16299:18;;16281:76;19579:35:0;;;;;;;;19627:46;32367:211;46329:137;46399:4;46423:35;46431:3;46451:5;46423:7;:35::i;3274:98::-;3332:7;3359:5;3363:1;3359;:5;:::i;50342:173::-;50417:6;;;-1:-1:-1;;;;;50434:17:0;;;-1:-1:-1;;;;;;50434:17:0;;;;;;;50467:40;;50417:6;;;50434:17;50417:6;;50467:40;;50398:16;;50467:40;50387:128;50342:173;:::o;46552:146::-;46629:4;39612:19;;;:12;;;:19;;;;;;:24;;46653:37;39515:129;32367:211;32511:58;;-1:-1:-1;;;;;6797:32:1;;32511:58:0;;;6779:51:1;6846:18;;;6839:34;;;32484:86:0;;32504:5;;-1:-1:-1;;;32534:23:0;6752:18:1;;32511:58:0;6734:145:1;32484:86:0;32367:211;;;:::o;20700:591::-;-1:-1:-1;;;;;20784:21:0;;20776:67;;;;-1:-1:-1;;;20776:67:0;;13634:2:1;20776:67:0;;;13616:21:1;13673:2;13653:18;;;13646:30;13712:34;13692:18;;;13685:62;-1:-1:-1;;;13763:18:1;;;13756:31;13804:19;;20776:67:0;13606:223:1;20776:67:0;-1:-1:-1;;;;;20943:18:0;;20918:22;20943:18;;;;;;;;;;;20980:24;;;;20972:71;;;;-1:-1:-1;;;20972:71:0;;8564:2:1;20972:71:0;;;8546:21:1;8603:2;8583:18;;;8576:30;8642:34;8622:18;;;8615:62;-1:-1:-1;;;8693:18:1;;;8686:32;8735:19;;20972:71:0;8536:224:1;20972:71:0;-1:-1:-1;;;;;21079:18:0;;:9;:18;;;;;;;;;;21100:23;;;21079:44;;21145:12;:22;;21117:6;;21079:9;21145:22;;21117:6;;21145:22;:::i;:::-;;;;-1:-1:-1;;21185:37:0;;16326:25:1;;;21211:1:0;;-1:-1:-1;;;;;21185:37:0;;;;;16314:2:1;16299:18;21185:37:0;;;;;;;32367:211;;;:::o;63063:87::-;63120:11;;;;;;;;;-1:-1:-1;;;;;63120:11:0;-1:-1:-1;;;;;63120:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63109:8;:33;63063:87::o;63158:265::-;63235:9;63230:128;63250:8;:15;63246:1;:19;63230:128;;;63312:11;;63334;;-1:-1:-1;;;;;63312:11:0;;;;:21;;63334:8;;63343:1;;63334:11;;;;;;:::i;:::-;;;;;;;63312:34;;;;;;;;;;;;;16326:25:1;;16314:2;16299:18;;16281:76;63312:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63287:9;:22;63297:8;63306:1;63297:11;;;;;;;;:::i;:::-;;;;;;;63287:22;;;;;;;;;;;:59;;;;63267:3;;;;;:::i;:::-;;;;63230:128;;;;63387:11;;;;;;;;;-1:-1:-1;;;;;63387:11:0;-1:-1:-1;;;;;63387:26:0;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63370:14;:45;-1:-1:-1;63158:265:0:o;63431:186::-;63514:9;63509:101;63529:8;:15;63525:1;:19;63509:101;;;63566:32;63586:8;63595:1;63586:11;;;;;;;;:::i;63566:32::-;-1:-1:-1;63546:3:0;;;;:::i;:::-;;;;63509:101;;63625:81;63678:11;;;;;;;;;-1:-1:-1;;;;;63678:11:0;-1:-1:-1;;;;;63678:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;46784:114::-;46844:7;46871:19;46879:3;39813:18;;39730:109;47252:137;47323:7;47358:22;47362:3;47374:5;47358:3;:22::i;37419:414::-;37482:4;39612:19;;;:12;;;:19;;;;;;37499:327;;-1:-1:-1;37542:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;37725:18;;37703:19;;;:12;;;:19;;;;;;:40;;;;37758:11;;37499:327;-1:-1:-1;37809:5:0;37802:12;;34940:716;35364:23;35390:69;35418:4;35390:69;;;;;;;;;;;;;;;;;35398:5;-1:-1:-1;;;;;35390:27:0;;;:69;;;;;:::i;:::-;35474:17;;35364:95;;-1:-1:-1;35474:21:0;35470:179;;35571:10;35560:30;;;;;;;;;;;;:::i;:::-;35552:85;;;;-1:-1:-1;;;35552:85:0;;15205:2:1;35552:85:0;;;15187:21:1;15244:2;15224:18;;;15217:30;15283:34;15263:18;;;15256:62;-1:-1:-1;;;15334:18:1;;;15327:40;15384:19;;35552:85:0;15177:232:1;38009:1420:0;38075:4;38214:19;;;:12;;;:19;;;;;;38250:15;;38246:1176;;38625:21;38649:14;38662:1;38649:10;:14;:::i;:::-;38698:18;;38625:38;;-1:-1:-1;38678:17:0;;38698:22;;38719:1;;38698:22;:::i;:::-;38678:42;;38754:13;38741:9;:26;38737:405;;38788:17;38808:3;:11;;38820:9;38808:22;;;;;;;;:::i;:::-;;;;;;;;;38788:42;;38962:9;38933:3;:11;;38945:13;38933:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;39047:23;;;:12;;;:23;;;;;:36;;;38737:405;39223:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;39318:3;:12;;:19;39331:5;39318:19;;;;;;;;;;;39311:26;;;39361:4;39354:11;;;;;;;38246:1176;39405:5;39398:12;;;;;40193:120;40260:7;40287:3;:11;;40299:5;40287:18;;;;;;;;:::i;:::-;;;;;;;;;40280:25;;40193:120;;;;:::o;27178:229::-;27315:12;27347:52;27369:6;27377:4;27383:1;27386:12;27347:21;:52::i;:::-;27340:59;27178:229;-1:-1:-1;;;;27178:229:0:o;28298:510::-;28468:12;28526:5;28501:21;:30;;28493:81;;;;-1:-1:-1;;;28493:81:0;;11401:2:1;28493:81:0;;;11383:21:1;11440:2;11420:18;;;11413:30;11479:34;11459:18;;;11452:62;-1:-1:-1;;;11530:18:1;;;11523:36;11576:19;;28493:81:0;11373:228:1;28493:81:0;24695:20;;28585:60;;;;-1:-1:-1;;;28585:60:0;;14847:2:1;28585:60:0;;;14829:21:1;14886:2;14866:18;;;14859:30;14925:31;14905:18;;;14898:59;14974:18;;28585:60:0;14819:179:1;28585:60:0;28659:12;28673:23;28700:6;-1:-1:-1;;;;;28700:11:0;28719:5;28726:4;28700:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28658:73;;;;28749:51;28766:7;28775:10;28787:12;28749:16;:51::i;:::-;28742:58;28298:510;-1:-1:-1;;;;;;;28298:510:0:o;30984:712::-;31134:12;31163:7;31159:530;;;-1:-1:-1;31194:10:0;31187:17;;31159:530;31308:17;;:21;31304:374;;31506:10;31500:17;31567:15;31554:10;31550:2;31546:19;31539:44;31304:374;31649:12;31642:20;;-1:-1:-1;;;31642:20:0;;;;;;;;:::i;14:247:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;142:1;139;132:12;94:2;181:9;168:23;200:31;225:5;200:31;:::i;266:251::-;336:6;389:2;377:9;368:7;364:23;360:32;357:2;;;405:1;402;395:12;357:2;437:9;431:16;456:31;481:5;456:31;:::i;522:388::-;590:6;598;651:2;639:9;630:7;626:23;622:32;619:2;;;667:1;664;657:12;619:2;706:9;693:23;725:31;750:5;725:31;:::i;:::-;775:5;-1:-1:-1;832:2:1;817:18;;804:32;845:33;804:32;845:33;:::i;:::-;897:7;887:17;;;609:301;;;;;:::o;915:456::-;992:6;1000;1008;1061:2;1049:9;1040:7;1036:23;1032:32;1029:2;;;1077:1;1074;1067:12;1029:2;1116:9;1103:23;1135:31;1160:5;1135:31;:::i;:::-;1185:5;-1:-1:-1;1242:2:1;1227:18;;1214:32;1255:33;1214:32;1255:33;:::i;:::-;1019:352;;1307:7;;-1:-1:-1;;;1361:2:1;1346:18;;;;1333:32;;1019:352::o;1376:667::-;1471:6;1479;1487;1495;1503;1556:3;1544:9;1535:7;1531:23;1527:33;1524:2;;;1573:1;1570;1563:12;1524:2;1612:9;1599:23;1631:31;1656:5;1631:31;:::i;:::-;1681:5;-1:-1:-1;1738:2:1;1723:18;;1710:32;1751:33;1710:32;1751:33;:::i;:::-;1803:7;-1:-1:-1;1857:2:1;1842:18;;1829:32;;-1:-1:-1;1913:2:1;1898:18;;1885:32;1926:33;1885:32;1926:33;:::i;:::-;1514:529;;;;-1:-1:-1;1514:529:1;;2032:3;2017:19;2004:33;;1514:529;-1:-1:-1;;1514:529:1:o;2048:315::-;2116:6;2124;2177:2;2165:9;2156:7;2152:23;2148:32;2145:2;;;2193:1;2190;2183:12;2145:2;2232:9;2219:23;2251:31;2276:5;2251:31;:::i;:::-;2301:5;2353:2;2338:18;;;;2325:32;;-1:-1:-1;;;2135:228:1:o;2368:383::-;2445:6;2453;2461;2514:2;2502:9;2493:7;2489:23;2485:32;2482:2;;;2530:1;2527;2520:12;2482:2;2569:9;2556:23;2588:31;2613:5;2588:31;:::i;:::-;2638:5;2690:2;2675:18;;2662:32;;-1:-1:-1;2741:2:1;2726:18;;;2713:32;;2472:279;-1:-1:-1;;;2472:279:1:o;2756:957::-;2840:6;2871:2;2914;2902:9;2893:7;2889:23;2885:32;2882:2;;;2930:1;2927;2920:12;2882:2;2970:9;2957:23;2999:18;3040:2;3032:6;3029:14;3026:2;;;3056:1;3053;3046:12;3026:2;3094:6;3083:9;3079:22;3069:32;;3139:7;3132:4;3128:2;3124:13;3120:27;3110:2;;3161:1;3158;3151:12;3110:2;3197;3184:16;3219:2;3215;3212:10;3209:2;;;3225:18;;:::i;:::-;3271:2;3268:1;3264:10;3254:20;;3294:28;3318:2;3314;3310:11;3294:28;:::i;:::-;3356:15;;;3387:12;;;;3419:11;;;3449;;;3445:20;;3442:33;-1:-1:-1;3439:2:1;;;3488:1;3485;3478:12;3439:2;3510:1;3501:10;;3520:163;3534:2;3531:1;3528:9;3520:163;;;3591:17;;3579:30;;3552:1;3545:9;;;;;3629:12;;;;3661;;3520:163;;;-1:-1:-1;3702:5:1;2851:862;-1:-1:-1;;;;;;;;2851:862:1:o;3718:277::-;3785:6;3838:2;3826:9;3817:7;3813:23;3809:32;3806:2;;;3854:1;3851;3844:12;3806:2;3886:9;3880:16;3939:5;3932:13;3925:21;3918:5;3915:32;3905:2;;3961:1;3958;3951:12;4000:919;4089:6;4142:3;4130:9;4121:7;4117:23;4113:33;4110:2;;;4159:1;4156;4149:12;4110:2;4192;4186:9;4234:3;4226:6;4222:16;4304:6;4292:10;4289:22;4268:18;4256:10;4253:34;4250:62;4247:2;;;4315:18;;:::i;:::-;4351:2;4344:22;4388:23;;4420:31;4388:23;4420:31;:::i;:::-;4475:5;4467:6;4460:21;;4542:2;4531:9;4527:18;4514:32;4509:2;4501:6;4497:15;4490:57;4608:2;4597:9;4593:18;4580:32;4575:2;4567:6;4563:15;4556:57;4674:2;4663:9;4659:18;4646:32;4641:2;4633:6;4629:15;4622:57;4731:3;4720:9;4716:19;4703:33;4745;4770:7;4745:33;:::i;:::-;4806:3;4794:16;;4787:33;4882:3;4867:19;;;4854:33;4836:16;;;4829:59;;;;-1:-1:-1;4798:6:1;4100:819;-1:-1:-1;4100:819:1:o;4924:180::-;4983:6;5036:2;5024:9;5015:7;5011:23;5007:32;5004:2;;;5052:1;5049;5042:12;5004:2;-1:-1:-1;5075:23:1;;4994:110;-1:-1:-1;4994:110:1:o;5109:184::-;5179:6;5232:2;5220:9;5211:7;5207:23;5203:32;5200:2;;;5248:1;5245;5238:12;5200:2;-1:-1:-1;5271:16:1;;5190:103;-1:-1:-1;5190:103:1:o;5298:435::-;5351:3;5389:5;5383:12;5416:6;5411:3;5404:19;5442:4;5471:2;5466:3;5462:12;5455:19;;5508:2;5501:5;5497:14;5529:1;5539:169;5553:6;5550:1;5547:13;5539:169;;;5614:13;;5602:26;;5648:12;;;;5683:15;;;;5575:1;5568:9;5539:169;;;-1:-1:-1;5724:3:1;;5359:374;-1:-1:-1;;;;;5359:374:1:o;5738:274::-;5867:3;5905:6;5899:13;5921:53;5967:6;5962:3;5955:4;5947:6;5943:17;5921:53;:::i;:::-;5990:16;;;;;5875:137;-1:-1:-1;;5875:137:1:o;6884:261::-;7063:2;7052:9;7045:21;7026:4;7083:56;7135:2;7124:9;7120:18;7112:6;7083:56;:::i;7570:383::-;7719:2;7708:9;7701:21;7682:4;7751:6;7745:13;7794:6;7789:2;7778:9;7774:18;7767:34;7810:66;7869:6;7864:2;7853:9;7849:18;7844:2;7836:6;7832:15;7810:66;:::i;:::-;7937:2;7916:15;-1:-1:-1;;7912:29:1;7897:45;;;;7944:2;7893:54;;7691:262;-1:-1:-1;;7691:262:1:o;9980:399::-;10182:2;10164:21;;;10221:2;10201:18;;;10194:30;10260:34;10255:2;10240:18;;10233:62;-1:-1:-1;;;10326:2:1;10311:18;;10304:33;10369:3;10354:19;;10154:225::o;13071:356::-;13273:2;13255:21;;;13292:18;;;13285:30;13351:34;13346:2;13331:18;;13324:62;13418:2;13403:18;;13245:182::o;16362:536::-;16647:6;16636:9;16629:25;16690:2;16685;16674:9;16670:18;16663:30;16610:4;16716:56;16768:2;16757:9;16753:18;16745:6;16716:56;:::i;:::-;16820:9;16812:6;16808:22;16803:2;16792:9;16788:18;16781:50;16848:44;16885:6;16877;16848:44;:::i;:::-;16840:52;16619:279;-1:-1:-1;;;;;;16619:279:1:o;17345:275::-;17416:2;17410:9;17481:2;17462:13;;-1:-1:-1;;17458:27:1;17446:40;;17516:18;17501:34;;17537:22;;;17498:62;17495:2;;;17563:18;;:::i;:::-;17599:2;17592:22;17390:230;;-1:-1:-1;17390:230:1:o;17625:128::-;17665:3;17696:1;17692:6;17689:1;17686:13;17683:2;;;17702:18;;:::i;:::-;-1:-1:-1;17738:9:1;;17673:80::o;17758:217::-;17798:1;17824;17814:2;;17868:10;17863:3;17859:20;17856:1;17849:31;17903:4;17900:1;17893:15;17931:4;17928:1;17921:15;17814:2;-1:-1:-1;17960:9:1;;17804:171::o;17980:168::-;18020:7;18086:1;18082;18078:6;18074:14;18071:1;18068:21;18063:1;18056:9;18049:17;18045:45;18042:2;;;18093:18;;:::i;:::-;-1:-1:-1;18133:9:1;;18032:116::o;18153:125::-;18193:4;18221:1;18218;18215:8;18212:2;;;18226:18;;:::i;:::-;-1:-1:-1;18263:9:1;;18202:76::o;18283:258::-;18355:1;18365:113;18379:6;18376:1;18373:13;18365:113;;;18455:11;;;18449:18;18436:11;;;18429:39;18401:2;18394:10;18365:113;;;18496:6;18493:1;18490:13;18487:2;;;-1:-1:-1;;18531:1:1;18513:16;;18506:27;18336:205::o;18546:380::-;18625:1;18621:12;;;;18668;;;18689:2;;18743:4;18735:6;18731:17;18721:27;;18689:2;18796;18788:6;18785:14;18765:18;18762:38;18759:2;;;18842:10;18837:3;18833:20;18830:1;18823:31;18877:4;18874:1;18867:15;18905:4;18902:1;18895:15;18931:135;18970:3;-1:-1:-1;;18991:17:1;;18988:2;;;19011:18;;:::i;:::-;-1:-1:-1;19058:1:1;19047:13;;18978:88::o;19071:127::-;19132:10;19127:3;19123:20;19120:1;19113:31;19163:4;19160:1;19153:15;19187:4;19184:1;19177:15;19203:127;19264:10;19259:3;19255:20;19252:1;19245:31;19295:4;19292:1;19285:15;19319:4;19316:1;19309:15;19335:127;19396:10;19391:3;19387:20;19384:1;19377:31;19427:4;19424:1;19417:15;19451:4;19448:1;19441:15;19467:127;19528:10;19523:3;19519:20;19516:1;19509:31;19559:4;19556:1;19549:15;19583:4;19580:1;19573:15;19599:131;-1:-1:-1;;;;;19674:31:1;;19664:42;;19654:2;;19720:1;19717;19710:12

Swarm Source

ipfs://1a37ad7d433fc0f7356568c901f55f4dabc28b8b9cabacb3b46c94c862e12b19

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